Schneider Electric EcoStruxure Machine Expert Mode d'emploi

EcoStruxure Machine Expert
Machine Code Analysis
Guide utilisateur
Traduction de la notice originale
EIO0000004079.02
10/2020
www.se.com
Mentions légales
La marque Schneider Electric et toutes les marques de commerce de Schneider
Electric SE et de ses filiales mentionnées dans ce guide sont la propriété de
Schneider Electric SE ou de ses filiales. Toutes les autres marques peuvent être des
marques de commerce de leurs propriétaires respectifs. Ce guide et son contenu
sont protégés par les lois sur la propriété intellectuelle applicables et sont fournis à
titre d'information uniquement. Aucune partie de ce guide ne peut être reproduite ou
transmise sous quelque forme ou par quelque moyen que ce soit (électronique,
mécanique, photocopie, enregistrement ou autre), à quelque fin que ce soit, sans
l'autorisation écrite préalable de Schneider Electric.
Schneider Electric n'accorde aucun droit ni aucune licence d'utilisation commerciale
de ce guide ou de son contenu, sauf dans le cadre d'une licence non exclusive et
personnelle, pour le consulter tel quel.
Les produits et équipements Schneider Electric doivent être installés, utilisés et
entretenus uniquement par le personnel qualifié.
Les normes, spécifications et conceptions sont susceptibles d'être modifiées à tout
moment. Les informations contenues dans ce guide peuvent faire l'objet de
modifications sans préavis.
Dans la mesure permise par la loi applicable, Schneider Electric et ses filiales
déclinent toute responsabilité en cas d'erreurs ou d'omissions dans le contenu
informatif du présent document ou pour toute conséquence résultant de l'utilisation
des informations qu'il contient.
©2021 Schneider Electric. Tous droits réservés.
Machine Code Analysis
Table des matières
Consignes de sécurité ................................................................................7
A propos de ce manuel ...............................................................................8
Introduction .............................................................................................. 11
Informations générales sur le composant Machine Code
Analysis ............................................................................................. 11
Concept de base de Machine Code Analysis.........................................13
Éditeurs d'analyse de code........................................................................17
Tableau des conventions .....................................................................17
Tableau des conventions ...............................................................17
Tableau des mesures ..........................................................................18
Tableau des mesures ....................................................................18
Vue de dépendance ............................................................................20
Vue de dépendance (présentation) .................................................20
Vue de dépendance (filtres) ...........................................................20
Vue de dépendance (graphe de dépendance) .................................21
Vue de dépendance (commandes du menu contextuel du graphe
de dépendance) ............................................................................22
Vue de dépendance (groupes) .......................................................23
BlockList ............................................................................................25
Liste de blocage............................................................................25
Gestionnaire d'analyse de code .................................................................27
Tableau de bord ..................................................................................27
Configuration......................................................................................28
Connexion au cloud ............................................................................29
Gestionnaire de requêtes d'analyse de code...............................................31
Rule Sets ..........................................................................................31
Référentiels de requêtes .....................................................................32
Éditeur de requêtes.............................................................................35
Éditeur de paramètres de chaînes de requête .......................................36
Éditeur de paramètres.........................................................................37
Connexion au cloud ............................................................................37
Commandes du menu contextuel...............................................................38
Commandes de menu contextuel des navigateurs.................................38
Instructions Pragma pour Machine Code Analysis.......................................39
Instructions Pragma pour Machine Code Analysis .................................39
Interface de création de scripts Python .......................................................41
Interface de création de scripts ............................................................41
Extensions des objets de script ............................................................41
Objets de script (API d'analyse de code)...............................................42
Comment ajouter des éditeurs d'analyse de code .......................................47
Comment avoir un aperçu rapide de l'application via le Tableau de
bord ...................................................................................................47
Comment obtenir des résultats détaillés sur les métriques de votre
application..........................................................................................48
Comment obtenir des résultats détaillés sur les conventions de votre
application..........................................................................................49
Comment afficher les dépendances de votre application avec des
requêtes prédéfinies dans la vue de dépendance ..................................50
EIO0000004079.02
3
Machine Code Analysis
Comment explorer étape par étape les dépendances de votre
application dans la vue de dépendance ................................................51
Annexes .....................................................................................................53
Requêtes de dépendance (filtre) ................................................................54
Requêtes de dépendance (filtre) ..........................................................54
Requêtes de dépendance (sélection) .........................................................56
Requêtes de dépendance (sélection) ...................................................56
Métriques.................................................................................................60
Métrique : taille de l'application (code) ..................................................60
Métrique : taille de l'application (code+données) ...................................61
Métrique : taille de l'application (données).............................................61
Métrique : Call In ................................................................................62
Métrique : Call Out ..............................................................................62
Métrique : taux de variables commentées (toutes) .................................62
Métrique : taux de variables commentées (entrée+sortie
+globale)............................................................................................63
Métrique : Cyclomatic Complexity ........................................................63
Métrique : Extended By .......................................................................65
Métrique : Extends ..............................................................................65
Métrique : Fan In.................................................................................66
Métrique : Fan Out ..............................................................................66
Métrique : Halstead Complexity............................................................67
Métrique : Implemented By ..................................................................70
Métrique : Implements.........................................................................71
Métrique : Lines Of Code (LOC) ...........................................................72
Métrique : Memory Size (Data).............................................................72
Métrique : Number Of Actions ..............................................................73
Métrique : Number Of GVL Usages ......................................................74
Métrique : nombre de lignes de commentaire en en-tête ........................74
Métrique : Number Of Instances...........................................................75
Métrique : Number Of Library References .............................................75
Métrique : Number Of Messages..........................................................76
Métrique : Number Of Methods ............................................................76
Métrique : nombre de commentaires multilignes ....................................77
Métrique : Number Of Properties..........................................................77
Métrique : Number Of Reads ...............................................................78
Métrique : Number Of Tasks ................................................................78
Métrique : Number Of Transitions.........................................................79
Métrique : Number Of Variables ...........................................................79
Métrique : Number Of Writes................................................................80
Métrique : Number Of FBD Networks....................................................80
Métrique : taux de commentaires dans le code source ...........................80
Métrique : Stack Size ..........................................................................81
Conventions.............................................................................................83
Requêtes de convention......................................................................83
Convention : messages de compilation.................................................86
Convention : POU complexe avec faible taux de commentaires..............86
Conventions : Vérifications des noms de types complexes .....................87
Conventions : Limite de profondeur d'héritage.......................................87
Convention : vérification de lecture de variable d'entrée .........................88
Convention : vérification du type de variable d'entrée.............................89
4
EIO0000004079.02
Machine Code Analysis
Convention : vérification d'écriture de variable d'entrée ..........................89
Convention : utilisation de commentaires multilignes .............................90
Convention : absence de commentaire en en-tête .................................91
Conventions : Nombre limite de méthodes ............................................91
Conventions : Nombre limite de propriétés............................................91
Convention : vérification de lecture de variable de sortie ........................92
Convention : vérification du type de variable de sortie ............................93
Convention : vérification d'utilisation de variables PERSISTENT.............93
Convention : vérification d'utilisation de variables RETAIN .....................93
Convention : variable non commentée (toutes)......................................94
Convention : variable non commentée (entrée+sortie+globale)...............94
Conventions : Vérification des variables inutilisées ................................94
Conventions : Vérification des noms de variable....................................95
Conventions : Vérification de la longueur des noms de variable ..............96
Index ...........................................................................................................97
EIO0000004079.02
5
Consignes de sécurité
Machine Code Analysis
Consignes de sécurité
Informations importantes
Lisez attentivement ces instructions et examinez le matériel pour vous familiariser
avec l'appareil avant de tenter de l'installer, de le faire fonctionner, de le réparer ou
d'assurer sa maintenance. Les messages spéciaux suivants que vous trouverez
dans cette documentation ou sur l'appareil ont pour but de vous mettre en garde
contre des risques potentiels ou d'attirer votre attention sur des informations qui
clarifient ou simplifient une procédure.
La présence de ce symbole sur une étiquette “Danger” ou “Avertissement” signale un
risque d'électrocution qui provoquera des blessures physiques en cas de non-respect
des consignes de sécurité.
Ce symbole est le symbole d'alerte de sécurité. Il vous avertit d'un risque de blessures
corporelles. Respectez scrupuleusement les consignes de sécurité associées à ce
symbole pour éviter de vous blesser ou de mettre votre vie en danger.
!
DANGER
DANGER signale un risque qui, en cas de non-respect des consignes de sécurité, provoque
la mort ou des blessures graves.
!
AVERTISSEMENT
AVERTISSEMENT signale un risque qui, en cas de non-respect des consignes de sécurité,
peut provoquer la mort ou des blessures graves.
!
ATTENTION
ATTENTION signale un risque qui, en cas de non-respect des consignes de sécurité, peut
provoquer des blessures légères ou moyennement graves.
AVIS
AVIS indique des pratiques n'entraînant pas de risques corporels.
Remarque Importante
L'installation, l'utilisation, la réparation et la maintenance des équipements
électriques doivent être assurées par du personnel qualifié uniquement.
Schneider Electric décline toute responsabilité quant aux conséquences de
l'utilisation de ce matériel.
Une personne qualifiée est une personne disposant de compétences et de
connaissances dans le domaine de la construction, du fonctionnement et de
l'installation des équipements électriques, et ayant suivi une formation en sécurité
leur permettant d'identifier et d'éviter les risques encourus.
EIO0000004079.02
7
Machine Code Analysis
A propos de ce manuel
A propos de ce manuel
Objectif du document
This document describes the graphical user interface of the Machine Code
Analysis and the functions it provides.
Champ d'application
This document has been updated for the release of EcoStruxureTM Machine
Expert V2.0.
Related Documents
Title of documenation
Reference number
EcoStruxure Machine Advisor Code Analysis
User Guide
EIO0000003915 (ENG);
EIO0000003917 (FRE);
EIO0000003916 (GER);
EIO0000003918 (SPA);
EIO0000003919 (ITA);
EcoStruxure Machine Expert Programming
Guide
EIO0000002854 (ENG);
EIO0000002855 (FRE);
EIO0000002856 (GER);
EIO0000002858 (SPA);
EIO0000002857 (ITA);
EIO0000002859 (CHS)
8
EIO0000004079.02
A propos de ce manuel
Machine Code Analysis
Information spécifique au produit
AVERTISSEMENT
PERTE DE CONTROLE
•
Le concepteur d'un système de commande doit envisager les modes de
défaillance possibles des chemins de commande et, pour certaines
fonctions de commande critiques, prévoir un moyen d'atteindre un état
sécurisé en cas de défaillance d'un chemin, et après cette défaillance. Par
exemple, l'arrêt d'urgence, l'arrêt en cas de surcourse, la coupure de courant
et le redémarrage sont des fonctions de contrôle cruciales.
•
Des canaux de commande séparés ou redondants doivent être prévus pour
les fonctions de commande critique.
•
Les liaisons de communication peuvent faire partie des canaux de
commande du système. Soyez particulièrement attentif aux implications des
retards de transmission imprévus ou des pannes de liaison.
•
Respectez toutes les réglementations de prévention des accidents ainsi que
les consignes de sécurité locales.1
•
Chaque implémentation de cet équipement doit être testée individuellement
et entièrement pour s'assurer du fonctionnement correct avant la mise en
service.
Le non-respect de ces instructions peut provoquer la mort, des blessures
graves ou des dommages matériels.
1
Pour plus d'informations, consultez les documents suivants ou leurs équivalents
pour votre site d'installation : NEMA ICS 1.1 (dernière édition), « Safety
Guidelines for the Application, Installation, and Maintenance of Solid State Control
» (Directives de sécurité pour l'application, l'installation et la maintenance de
commande statique) et NEMA ICS 7.1 (dernière édition), « Safety Standards for
Construction and Guide for Selection, Installation, and Operation of AdjustableSpeed Drive Systems » (Normes de sécurité relatives à la construction et manuel
de sélection, d'installation et d'exploitation de variateurs de vitesse).
AVERTISSEMENT
FONCTIONNEMENT IMPRÉVU DE L'ÉQUIPEMENT
•
N'utilisez que le logiciel approuvé par Schneider Electric pour faire
fonctionner cet équipement.
•
Mettez à jour votre programme d'application chaque fois que vous modifiez
la configuration matérielle physique.
Le non-respect de ces instructions peut provoquer la mort, des blessures
graves ou des dommages matériels.
Terminology Derived from Standards
Les termes techniques, la terminologie, les symboles et les descriptions
correspondantes employés dans ce manuel ou figurant dans ou sur les produits
proviennent généralement des normes internationales.
Dans les domaines des systèmes de sécurité fonctionnelle, des variateurs et de
l'automatisme en général, les termes employés sont sécurité, fonction de sécurité,
état sécurisé, défaut, réinitialisation du défaut, dysfonctionnement, panne, erreur,
message d'erreur, dangereux, etc.
Entre autres, les normes concernées sont les suivantes :
EIO0000004079.02
9
Machine Code Analysis
A propos de ce manuel
Norme
Description
IEC 61131-2:2007
Automates programmables - Partie 2 : exigences et essais des
équipements
ISO 13849-1:2015
Sécurité des machines : parties des systèmes de commande relatives à
la sécurité.
Principes généraux de conception
EN 61496-1:2013
Sécurité des machines : équipements de protection électro-sensibles.
Partie 1 : Prescriptions générales et essais
ISO 12100:2010
Sécurité des machines - Principes généraux de conception Appréciation du risque et réduction du risque
EN 60204-1:2006
Sécurité des machines - Équipement électrique des machines - Partie 1
: règles générales
ISO 14119:2013
Sécurité des machines - Dispositifs de verrouillage associés à des
protecteurs - Principes de conception et de choix
ISO 13850:2015
Sécurité des machines - Fonction d'arrêt d'urgence - Principes de
conception
IEC 62061:2015
Sécurité des machines - Sécurité fonctionnelle des systèmes de
commande électrique, électronique et électronique programmable
relatifs à la sécurité
IEC 61508-1:2010
Sécurité fonctionnelle des systèmes électriques/électroniques/
électroniques programmables relatifs à la sécurité : prescriptions
générales.
IEC 61508-2:2010
Sécurité fonctionnelle des systèmes électriques/électroniques/
électroniques programmables relatifs à la sécurité : exigences pour les
systèmes électriques/électroniques/électroniques programmables
relatifs à la sécurité.
IEC 61508-3:2010
Sécurité fonctionnelle des systèmes électriques/électroniques/
électroniques programmables relatifs à la sécurité : exigences
concernant les logiciels.
IEC 61784-3:2016
Réseaux de communication industriels - Profils - Partie 3 : Bus de terrain
de sécurité fonctionnelle - Règles générales et définitions de profils.
2006/42/EC
Directive Machines
2014/30/EU
Directive sur la compatibilité électromagnétique
2014/35/EU
Directive sur les basses tensions
De plus, des termes peuvent être utilisés dans le présent document car ils
proviennent d'autres normes telles que :
Norme
Description
Série IEC 60034
Machines électriques rotatives
Série IEC 61800
Entraînements électriques de puissance à vitesse variable
Série IEC 61158
Communications numériques pour les systèmes de mesure et de
commande – Bus de terrain utilisés dans les systèmes de commande
industriels
Enfin, le terme zone de fonctionnement utilisé dans le contexte de la description
de dangers spécifiques a la même signification que les termes zone dangereuse
ou zone de danger employés dans la directive Machines (2006/42/EC) et la norme
ISO 12100:2010.
NOTE: Les normes susmentionnées peuvent s'appliquer ou pas aux produits
cités dans la présente documentation. Pour plus d'informations sur chacune
des normes applicables aux produits décrits dans le présent document,
consultez les tableaux de caractéristiques de ces références de produit.
10
EIO0000004079.02
Introduction
Machine Code Analysis
Introduction
Informations générales sur le composant Machine Code Analysis
Présentation
Le composant Machine Code Analysis est intégré dans EcoStruxure Machine
Expert et permet d'analyser des applications.
Machine Code Analysis remplit les principales fonctions suivantes :
•
Compréhension de la structure du code source. Les développeurs de
logiciels peuvent visualiser les dépendances dans le code et les explorer de
façon détaillée, par exemple.
•
Identification des déficiences du code pour harmoniser et améliorer le code
source en fonction des instructions de programmation définies.
•
Mesure de la qualité du code source et identification des KPI (indicateurs de
performance clés).
•
Transmission des KPI aux développeurs de logiciels pour leur usage
personnel.
Configuration système requise
Les exigences suivantes relatives au matériel et au système d'exploitation
s'appliquent à Machine Code Analysis, en plus de la configuration système
requise pour EcoStruxure Machine Expert.
Configuration minimale :
•
4 cœurs de processeur pour l'exécution parallèle des requêtes
•
4 Go de RAM
Exigences recommandées pour l'analyse de projets :
•
Windows 64 bits
•
Au moins 4 cœurs de processeur pour l'exécution parallèle des requêtes
•
Au moins 8 Go de RAM
Installation
Pour être utilisé dans EcoStruxure Machine Expert, le composant Machine Code
Analysis doit être installé à l'aide de Schneider Electric Software Installer.
Machine Code Analysis est protégé par une licence :
Fonction
Sans licence
Avec licence
Vue de dépendance
Deux diagrammes maximum
Aucune limite
Tableau des mesures
Deux objets et trois requêtes
actives maximum
Aucune limite
Tableau des conventions
Deux objets et trois requêtes
actives maximum
Aucune limite
Éditeur de requêtes
Non disponible
Disponible
API CodeAnalysis Python
Non disponible
Disponible
NOTE: Pour plus d'informations sur la licence du produit, contactez votre
représentant Schneider Electric.
EIO0000004079.02
11
Machine Code Analysis
Introduction
Éditeurs d'analyse de code
EcoStruxure Machine Expert Logic Builder inclut trois éditeurs qui permettent
d'analyser du code et d'en interpréter les résultats :
•
Éditeur, page 17 Tableau des conventions
Parties de l'application qui ne respectent pas les conventions de codage
définies (basées sur des règles de codage).
•
Éditeur, page 20 Vue de dépendance
Dépendances entre les noms d'espace, les bibliothèques et les objets (blocs
fonction, POU, etc.).
•
Éditeur, page 18 Tableau des mesures
Résultats des métriques de qualité du code (lignes de code, complexité, etc.).
Il est possible d'ajouter plusieurs objets d'analyse de code sous les dossiers
Application ou le Gestionnaire d'analyse de code.
Vous pouvez ajouter plusieurs objets d'analyse de code à une application.
Si un objet Tableau des conventions ou Tableau des mesures est ajouté sous
Application ou Gestionnaire d'analyse de code, l'application entière est
considérée par l'analyse.
Si ces objets sont ajoutés sous un dossier, seul ce dossier est considéré par
l'analyse.
Il est donc possible de stocker dans des objets dédiés les résultats d'analyse
correspondant à chaque module/dossier d'une application (par exemple).
L'ajout d'un objet Tableau des conventions, Vue de dépendance ou Tableau
des mesures à une application entraîne l'ajout automatique d'un Gestionnaire
d'analyse de code à l'objet Application.
BlockList
A BlockList object can be added beneath a Code Analysis Manager object. The
BlockList object contains elements that will not appear in Conventions Table,
Metrics Table, or Dashboard results. This, although, is taken into account when
you upload a project snapshot, page 29 into Machine Advisor Code Analysis.
Gestionnaire d'analyse de code
The Code Analysis Manager provides a quick overview via a dashboard and you
can configure analysis depth and the cloud connection.
The Code Analysis Manager provides the tabs:
•
Dashboard tab, page 27
Overview of the analyzed application.
•
Configuration tab, page 28
Analysis depth of code analysis configuration.
•
Cloud Connection tab, page 29
Configuration of the connection to the Machine Advisor Code Analysis.
Gestionnaire de requêtes d'analyse de code
The Code Analysis Query Manager allows you to create and modify customized
rule sets, and to manage your metrics and conventions queries. To open the Code
Analysis Query Manager click Tools in the menu bar and select Code Analysis
Query Manager from the contextual menu.
The Code Analysis Query Manager provides the tabs:
•
12
Rule Sets
EIO0000004079.02
Introduction
Machine Code Analysis
Rule sets can be created and modified.
•
Metric Queries tab, page 60
Queries and query chains available in the Metrics Table editor can be
created and modified.
•
Convention Queries tab, page 83
Queries and query chains available in the Conventions Table editor can be
created and modified.
•
Dependency (Filter) Queries tab, page 54
Queries and query chains available in the Filters of the Dependency View
editor can be created and modified.
•
Dependency (Select) Queries tab, page 56
Queries and query chains available in the Select and Add dialog of the
Dependency View editor can be created and modified.
•
Cloud Connection tab, page 37
The connection to Machine Advisor Code Analysis can be configured.
Concept de base de Machine Code Analysis
Présentation
Ce chapitre présente les concepts de base du composant Machine Code Analysis
intégré dans EcoStruxure Machine Expert.
Composants logiciels de Machine Code Analysis
Le schéma suivant propose une vue d'ensemble des principaux composants
logiciels de Machine Code Analysis :
Ces composants peuvent être classés dans trois catégories :
•
•
EIO0000004079.02
Les composants de l'interface utilisateur qui affichent des données :
◦
Éditeurs permettant d'écrire du code source
◦
Éditeurs permettant de visualiser les résultats concernant les métriques
ou les conventions, ou la structure du code source sous forme graphique
Les modèles de données utilisés comme entrée ou sortie pour d'autres
composants :
◦
Modèle de langage
◦
Modèle de dépendance
◦
Modèle RDF
13
Machine Code Analysis
Introduction
◦
•
Résultats de requête
Les composants qui transforment des données :
◦
Le compilateur de code source (avec modèle de langage en sortie) vérifie
la syntaxe du code source et crée le modèle de langage qui permet de
générer le code exécuté sur des contrôleurs.
◦
L'analyseur de code source (avec modèle de dépendance en sortie)
analyse le modèle de langage, le transforme en modèle de dépendance et
met à jour le modèle de dépendance.
◦
Le générateur de modèles RDF (avec modèle RDF en sortie) transforme
le modèle de dépendance en modèle RDF pour faire le lien avec les
technologies de Web sémantique.
◦
Le moteur d'exécution de requêtes (avec résultats de requête en sortie)
exécute des requêtes SPARQL sur le modèle RDF afin d'obtenir les
résultats correspondants.
Données d'analyse (modèle de dépendance)
L'application est analysée et un modèle de dépendance est généré.
Le modèle de dépendance est constitué de nœuds connectés via des fronts.
Exemples de types de nœuds :
Type de nœud
Description
Bloc fonction
Bloc fonction (FB) dans le modèle de dépendance. Créé pour chaque
bloc fonction ajouté au projet EcoStruxure Machine Expert.
Programme
Programme (PRG) dans le modèle de dépendance. Créé pour chaque
programme ajouté au projet EcoStruxure Machine Expert.
Fonction
Fonction (FC) dans le modèle de dépendance. Créé pour chaque
fonction ajoutée au projet EcoStruxure Machine Expert.
à
...
Exemples de types de fronts :
Type de front
Description
Lecture
Opération de lecture depuis le code (source) vers un nœud de variable
(cible).
Écriture
Opération d'écriture depuis le code (source) vers un nœud de variable
(cible).
Appel
Appel d'un élément (bloc fonction, méthode, action, programme, etc.)
depuis le code (source) vers un nœud cible.
Extension
Extension d'un type de base. Exemple : extension d'un bloc fonction par
un autre bloc.
...
...
Phases d'analyse
L'analyseur de code source, un des principaux composants de l'analyse de code,
transforme le modèle de langage en modèle de dépendance (les données
d'analyse).
14
EIO0000004079.02
Introduction
Machine Code Analysis
Cet analyseur s'appuie sur le concept des phases d'analyse, qui permet de
simplifier le processus et d'optimiser les performances (sur le plan de la mémoire
et du processeur).
Exemple :
•
L'analyse de code permettant d'obtenir les dépendances d'extension et
d'implémentation est plus rapide comparé à celle renvoyant les dépendances
d'appel, de lecture ou d'écriture.
•
Pour obtenir la liste des blocs fonction et des dépendances d'extension et
d'implémentation, il suffit d'interrompre l'analyse à un niveau donné.
•
Si vous avez besoin de plus de détails, augmentez la profondeur de l'analyse
pour les éléments souhaités (pour visualiser des blocs fonction spécifiques
dans la vue de dépendance, par exemple) ou pour les objets du projet (pour
obtenir les résultats sur les métriques, par exemple).
Phases d'analyse pertinentes pour l'utilisateur :
Les trois approches suivantes sont pertinentes :
•
Profondeur d'analyse minimale (phases 1+2) : contenu visible dans le projet
et les navigateurs d'EcoStruxure Machine Expert
◦
Blocs fonction, programmes, fonctions, DUT, etc.
◦
Propriétés et méthodes Get/Set associées
◦
Méthodes
◦
Actions
◦
Informations structurelles (dossier, etc.)
◦
Références de bibliothèques
Avec cette profondeur, l'analyse prend le moins de temps.
•
Profondeur d'analyse intermédiaire (phases 3+4) : niveau d'informations
inférieur dans le code source
Par exemple :
◦
Variables
◦
Lecture des dépendances de variable
◦
Écriture des dépendances de variable
◦
Appel des méthodes, fonctions, blocs fonction, programmes, etc.
Avec cette profondeur, l'analyse prend beaucoup de temps.
•
Profondeur d'analyse maximale (phase 5) : informations concernant les
métriques basées sur l'implémentation (le code source)
Par exemple :
◦
Halstead Complexity
◦
Lines Of Code (LOC)
◦
...
Avec cette profondeur, l'analyse prend le plus de temps. Réservé aux métriques
ou aux conventions.
Technologies de Web sémantique
Ouverte et flexible, la fonction d'analyse de code s'appuie sur plusieurs
technologies de Web sémantique, notamment :
•
Structure Resource Description Framework (RDF) - Modèle RDF
Consultez la page https://en.wikipedia.org/wiki/Resource_Description_
Framework.
•
Base de données RDF (base de données de Web sémantique) - espace
Triple Storage RDF
Consultez la page https://en.wikipedia.org/wiki/Triplestore.
•
EIO0000004079.02
Protocole SPARQL et langage de requête RDF - SPARQL
15
Machine Code Analysis
Introduction
Consultez le document https://en.wikipedia.org/wiki/SPARQL.
Synchronisation entre le modèle de dépendance et le modèle RDF
Le modèle de dépendance est généré suite à une opération d'analyse de code.
Il est synchronisé avec un modèle RDF pour faire le lien avec une fonction
d'analyse de code ouverte et flexible qui prend en charge le langage de requête.
Triple Storage RDF
Pour permettre l'analyse de projets volumineux, le modèle RDF appartient à un
processus séparé appelé Triple Storage RDF.
Le Triple Storage RDF est utilisé par défaut. Au besoin, il est possible de
configurer son comportement à l'aide du Gestionnaire d'analyse de code.
SPARQL et RDF
La structure Resource Description Framework (RDF) désigne un modèle de
données décrivant des ressources ainsi que les relations qui les lient.
Exemple :
:(Sujet)
:(Prédicat)
:(Objet)
:Car
:Weights
:1000 kg
:Car
:ConsistsOf
:Wheels
:Car
:ConsistsOf
:Engine
SPARQL est l'acronyme de « Sparql Protocol and RDF Query Language ». La
spécification SPARQL (https://www.w3.org/TR/sparql11-overview/) définit les
langages et protocoles qui permettent d'interroger et de manipuler des graphes
RDF (à l'instar des requêtes SQL).
Exemple de requête SPARQL simple permettant d'obtenir l'ID de nœud et le nom
des blocs fonction d'un modèle RDF :
SELECT ?NodeId ?Name
WHERE {
# Select all FunctionBlocks and their names
?NodeId a :FunctionBlock ;
:Name ?Name .
}
16
EIO0000004079.02
Éditeurs d'analyse de code
Machine Code Analysis
Éditeurs d'analyse de code
Tableau des conventions
Tableau des conventions
Présentation
With the Conventions Table, you can select conventions that have to be met by
your application.
Le Tableau des conventions se divise en deux parties :
•
Conventions (à gauche)
Liste des conventions disponibles.
Consultez le chapitre Onglet Requêtes de convention, page 83.
•
Fenêtre des résultats (à droite)
Liste des éléments qui ne respectent pas les conventions sélectionnées à
gauche.
Conventions
L'arborescence Conventions répertorie et regroupe les règles de convention
disponibles par défaut (avec l'installation d'EcoStruxure Machine Expert) ainsi que
celles définies par l'utilisateur à l'aide de l'Éditeur de requêtes. Utilisez les cases
à cocher pour activer ou désactiver les règles de convention.
Lorsque vous cliquez sur le bouton Activer et commencer l'interrogation dans
la barre d'outils de la fenêtre des résultats, des informations supplémentaires
s'affichent dans l'arborescence Conventions :
Elément
Description
Filtrer par noms de
conventions
Entrez le texte permettant de filtrer les conventions par nom.
Jeu de règles
Sélectionnez un jeu de règles pour filtrer les conventions à
afficher.
(<Nombre>) après un nom de
convention
Indique le nombre de résultats créés par cette convention. Si
aucune valeur n'apparaît, la requête n'a pas été exécutée.
(Demandez) après un nom de
convention
Cette requête est en cours d'exécution.
Barre d'outils
Elément
Description
Analyser le code
Cliquez sur ce bouton pour lancer l'analyse de l'application
associée à ce Tableau des conventions. Lorsque l'analyse est
en cours et à jour, ce bouton est désactivé.
Etape: x/y (Obligatoire: z)
Informations d'étape associées au bouton Analyser le code :
Interrogation
•
Nombre d'étapes disponibles (y)
•
Étape actuellement atteinte (x)
•
Étape à atteindre (z) pour utiliser cet éditeur
•
Bouton Activer et commencer l'interrogation :
Cliquez sur ce bouton pour commencer l'interrogation.
•
Bouton Désactiver et interrompre l'interrogation :
Cliquez sur ce bouton pour interrompre l'interrogation.
Cliquez de nouveau sur ce bouton pour relancer
l'interrogation à partir de là où vous l'avez arrêtée.
EIO0000004079.02
17
Machine Code Analysis
Éditeurs d'analyse de code
Elément
Description
Exporter
Cliquez sur ce bouton pour exporter la liste affichée au format
CSV, HTML ou XML.
Portée
Affiche le dossier dont le Tableau des conventions fait partie.
Seul ce dossier est pris en compte pour l'analyse. Pour un
tableau défini comme un sous-noeud du Gestionnaire
d'analyse de code, l'application entière est prise en compte
par l'analyse. Visible uniquement si un Tableau des
conventions est placé dans un dossier.
Liste de résultats
Elément
Description
Filtrer par
Saisissez du texte pour filtrer les résultats. Le filtre s'applique à
toutes les colonnes.
Tri d'une colonne
Pour trier une colonne, cliquez sur son en-tête :
•
Convention
•
Pondération
•
Nom complet
•
Message
Double-clic sur une entrée du
tableau
Ouvre l'élément associé dans l'éditeur correspondant.
Commandes du menu
contextuel d'une entrée de
tableau
Cliquez avec le bouton droit de la souris sur une entrée du
tableau, puis sélectionnez l'une des commandes suivantes
dans le menu contextuel :
•
Atteindre la définition
Ouvre l'élément associé dans l'éditeur correspondant.
•
Ajouter au graphe de dépendance
Ajoute l'élément à un graphe de dépendance nouveau ou
existant.
•
Ajouter à la liste de blocage
Ajoute l'élément à une liste de blocage et le supprime de
tous les Tableaux des conventions jusqu'à ce qu'il soit
de nouveau supprimé de cette liste.
Tableau des mesures
Tableau des mesures
Présentation
With the Metrics Table, you can select metrics to be executed on an application
and filter and list results.
Le Tableau des mesures se divise en deux parties :
•
Métriques (à gauche)
Liste des métriques disponibles., page 60
•
Fenêtre des résultats (à droite)
Liste des résultats correspondant aux métriques.
Métriques
L'arborescence Métriques répertorie les métriques disponibles par défaut (avec
l'installation d'EcoStruxure Machine Expert) ainsi que celles définies par
l'utilisateur à l'aide de l'Éditeur de requêtes. Utilisez les cases à cocher pour
activer ou désactiver les métriques.
18
EIO0000004079.02
Éditeurs d'analyse de code
Machine Code Analysis
Lorsque vous cliquez sur le bouton Activer et commencer l'interrogation dans
la barre d'outils de la fenêtre des résultats, des informations supplémentaires
s'affichent dans l'arborescence Métriques :
Elément
Description
Filtrer par noms de métrique
Entrez le texte permettant de filtrer les métriques par nom.
Jeu de règles
Sélectionnez un jeu de règles pour filtrer les métriques à
afficher.
(<Nombre>) après un nom de
métrique
Indique le nombre de résultats créés par cette métrique. Si
aucune valeur n'apparaît, la requête n'a pas été exécutée.
(Demandez) après un nom de
métrique
Cette requête est en cours d'exécution.
Barre d'outils
Elément
Description
Analyser le code
Cliquez sur ce bouton pour lancer l'analyse de l'application
associée à ce Tableau des mesures. Si l'analyse a déjà
commencé et que son état est à jour, ce bouton est désactivé.
Interrogation
•
Bouton Activer et commencer l'interrogation :
Cliquez sur ce bouton pour commencer l'interrogation.
•
Bouton Désactiver et interrompre l'interrogation :
Cliquez sur ce bouton pour interrompre l'interrogation.
Cliquez de nouveau sur ce bouton pour relancer
l'interrogation à partir de là où vous l'avez arrêtée.
Exporter
Cliquez sur ce bouton pour exporter la liste affichée au format
CSV, HTML ou XML.
Portée
Affiche le dossier dont le Tableau des mesures fait partie. Seul
ce dossier est pris en compte par l'analyse. Pour un tableau
défini comme un sous-noeud du Gestionnaire d'analyse de
code, l'application entière est prise en compte par l'analyse.
Visible uniquement si un Tableau des mesures est placé dans
un dossier.
Liste de résultats
Elément
Description
Filtrer par
Saisissez du texte pour filtrer les résultats. Le filtre s'applique à
toutes les colonnes.
Tri d'une colonne
Pour trier une colonne, cliquez sur son en-tête :
•
Type
•
Nom
•
Nom complet
•
<Nom de la métrique>
Double-clic sur une entrée du
tableau
Ouvre l'élément associé dans l'éditeur correspondant.
Commandes du menu
contextuel d'une entrée de
tableau
Cliquez avec le bouton droit de la souris sur une entrée du
tableau, puis sélectionnez l'une des commandes suivantes
dans le menu contextuel :
•
Atteindre la définition
Ouvre l'élément associé dans l'éditeur correspondant.
•
Ajouter au graphe de dépendance
Ajoute l'élément à un graphe de dépendance nouveau ou
existant.
•
Ajouter à la liste de blocage
Ajoute l'élément à une liste de blocage et le supprime de
tous les Tableaux des mesures jusqu'à ce qu'il soit de
nouveau supprimé de cette liste.
EIO0000004079.02
19
Machine Code Analysis
Éditeurs d'analyse de code
Vue de dépendance
Vue de dépendance (présentation)
Présentation
With the Dependency View, you can visualize the dependencies of your analyzed
application as a dependency graph. You can select the content and the layout of
the dependency graph.
La Vue de dépendance se divise en trois parties :
•
Filtres (à gauche), page 20
Vous pouvez filtrer et configurer le graphe de dépendance.
•
Graphe de dépendance (fenêtre principale), page 21
Le graphe affiché représente les dépendances entre les éléments de
l'application analysée.
•
Groupes (à droite), page 23
Vous pouvez structurer l'application à l'aide de l'arborescence Groupes.
Vue de dépendance (filtres)
Présentation
Elément
Description
Sélectionnez le filtre pour
afficher le graphique
Sélectionnez un filtre dans la liste. Les filtres sont définis dans
l'onglet Requêtes de dépendance (filtre) du Code Analysis
Query Manager.
Consultez le chapitre Onglet Requêtes de dépendance (filtre),
page 54.
Appliquer
Cliquez sur ce bouton pour appliquer le filtre au graphe affiché.
Types de filtres rapides
This tree lists the Edge Types and Node Types based on the
content in the Dependency Graph.
If you activate / deactivate Edge Types or Node Types in the
list, the displayed graph is updated immediately.
Options de visualisation local
•
Afficher les étiquettes locals
Active/désactive les étiquettes associées aux fronts dans
le Graphe de dépendance.
•
Afficher les fronts parallèles
Active/désactive l'affichage des fronts parallèles.
20
EIO0000004079.02
Éditeurs d'analyse de code
Machine Code Analysis
Vue de dépendance (graphe de dépendance)
Présentation
Consultez également la section Commandes du menu contextuel du graphe de
dépendance, page 22.
Barre d'outils
Elément
Description
Analyser le code
Cliquez sur ce bouton pour lancer l'analyse de l'application
associée à cette Vue de dépendance. Si l'analyse a déjà
commencé et que son état est à jour, ce bouton est désactivé.
Pointeur de souris
Cliquez sur ce bouton pour passer du mode déplacement au
mode sélection, et inversement.
Sélectionner et ajouter
Une fois l'analyse de code exécutée, cliquez sur ce bouton
pour définir les champs Sélectionnez Scope et Sélectionnez
la requête.
Les portées suivantes sont disponibles :
•
Projet entier
Les résultats attendus sont les objets de l'application, de
l'espace POU et des bibliothèques référencées par
l'application.
NOTE: Un grand nombre d'objets peuvent ainsi être
renvoyés.
•
Application + espace POU
Les résultats attendus sont les objets de l'application et
de l'espace POU (= éléments de projet visibles dans les
navigateurs d'EcoStruxure Machine Expert).
Les objets de bibliothèque ne sont pas renvoyés dans les
résultats.
•
Application
Les résultats attendus sont les objets définis uniquement
dans l'application.
•
Espace POU
Les résultats attendus sont les objets définis uniquement
dans l'espace POU.
Consultez le chapitre Onglet Requêtes de dépendance
(sélection), page 56.
Effacer
Cliquez sur ce bouton pour supprimer tous les nœuds du
graphe affiché.
Exporter
Cliquez sur ce bouton pour exporter le graphe affiché en tant
qu'image (*.jpg, *.png ou *.bmp).
Disposition
Sélectionnez une disposition prédéfinie pour le graphe affiché.
Vous avez le choix entre plusieurs dispositions circulaires,
dirigées par la force et en arborescence.
Appliquer
Cliquez sur ce bouton pour réorganiser les objets sur le graphe
affiché en fonction de la disposition sélectionnée.
Contrôle de zoom
With the zoom control in the lower right corner of the dependency graph window,
you can modify the size and the position of the displayed graph.
EIO0000004079.02
Type
Description
Curseur
Utilisez le curseur pour effectuer un zoom avant ou arrière.
Remplir les limites avec du
contenu
Cliquez sur ce bouton pour que le contenu remplisse
entièrement le graphe de dépendance.
21
Machine Code Analysis
Éditeurs d'analyse de code
Type
Description
Centrer le contenu
Cliquez sur ce bouton pour que le contenu s'affiche au centre
du graphe de dépendance.
Fermer
Cliquez sur ce bouton pour fermer le contrôle de zoom. Pour le
rouvrir, cliquez sur l'icône dans le coin inférieur droit du graphe
de dépendance.
Pour déplacer le contenu dans la fenêtre du graphe de dépendance, cliquez
dans la fenêtre > déplacez le curseur tout en maintenant le bouton gauche
de la souris enfoncé.
Déplacer des nœuds vers le graphe de dépendance à l'aide de
la méthode glisser-déposer
Vous pouvez également ajouter des nœuds et des sous-nœuds dans le graphe de
dépendance par glisser-déposer. Pour cela, faites glisser le nœud souhaité
depuis l'arborescence Application vers la fenêtre du graphe de dépendance.
Vue de dépendance (commandes du menu contextuel du graphe de dépendance)
Commandes du menu contextuel des nœuds du graphe
Commande de menu
Description
Sélectionner tout
Sélectionne les nœuds du graphe.
Peut être exécutée n'importe où sur le graphe.
Atteindre la définition
Ouvre l'éditeur du nœud sélectionné.
Peut être exécutée sur tous les nœuds sauf : Application, Espace
POU, Tâche, Dossier.
Enlever node(s)
Supprime le ou les nœuds sélectionnés sur le graphe.
Supprimer tout sauf moi
Supprime le ou les nœuds du graphe, sauf celui sélectionné.
Supprimer tout sauf moi et
mes dépendances directes
Supprime le ou les nœuds du graphe, sauf celui sélectionné et ses
nœuds associés. Peut être exécutée sur tous les nœuds, sauf les
groupes.
Supprimer les groupes
Supprime les groupes sélectionnés de la vue de dépendance et du
projet. Les nœuds affectés n'appartiennent plus à un groupe.
Peut être exécutée uniquement sur des groupes.
Affecter à un groupe
nouveau ou existant
Affecte les nœuds sélectionnés à un groupe nouveau ou existant.
Peut être exécutée sur les nœuds de l'application active, sauf :
Action, Méthode, Propriété, Transition, Variable, Bibliothèque.
Ajouter tous mes
Propriétés et variables
Ajoute au graphe les variables et les propriétés définies dans le
nœud sélectionné.
Peut être exécutée sur : Liste des variables globales,
Programme, Bloc fonction, Fonction, Méthode, Transition,
Action.
22
Ajouter tous mes enfants
de groupe
Ajoute au graphe les nœuds et les groupes du groupe sélectionné.
Ajouter mon groupe parent
Ajoute au graphe le groupe auquel est affecté le nœud sélectionné.
Ajouter tous mes Actions
Ajoute au graphe les actions définies dans le bloc fonction ou le
programme sélectionné.
Ajouter tous mes
Méthodes
Ajoute au graphe les méthodes définies dans le bloc fonction ou
le programme sélectionné.
Ajouter tous mes
Transitions
Ajoute au graphe les transitions définies dans le bloc fonction ou
le programme sélectionné.
Ajouter tous mes Valeurs
d'énumération
Ajoute les valeurs d'énumération définies dans l'énumération
sélectionnée.
EIO0000004079.02
Éditeurs d'analyse de code
Machine Code Analysis
Commande de menu
Description
Tout ajouter Interfaces Je
suis en train de mettre en
œuvre
Ajoute au graphe les interfaces implémentées par le bloc fonction
sélectionné.
Tout ajouter
FunctionBlocks qui
m'étendent
Ajoute au graphe les blocs fonction qui étendent le bloc fonction
sélectionné.
Tout ajouter Interfaces qui
m'étendent
Ajoute au graphe les interfaces qui étendent l'interface
sélectionnée.
Tout ajouter
FunctionBlocks que
j'étends
Ajoute au graphe les blocs fonction étendus par le bloc fonction
sélectionné.
Tout ajouter Interfaces que
j'étends
Ajoute au graphe les interfaces étendues par l'interface
sélectionnée.
Tout ajouter Variables et
propriétés qui
m'instancient
Ajoute les variables et les propriétés qui font référence au bloc
fonction ou à l'énumération sélectionné(e).
Ajouter tous les nœuds
appelés par ce/cette XX
Ajoute au graphe les nœuds appelés par le nœud sélectionné.
Peut être exécutée sur : Programme, Bloc fonction, Fonction,
Méthode, Transition, Action.
Ajouter tous les nœuds qui
appellent ce/cette XX
Ajoute au graphe les nœuds qui appellent le nœud sélectionné.
Peut être exécutée sur : Programme, Bloc fonction, Fonction,
Méthode, Transition, Action.
Tout ajouter Variables et
Propriétés Je lis ou j'écris
Ajoute au graphe les variables et les propriétés lues ou écrites par
le nœud sélectionné.
Peut être exécutée sur : Programme, Bloc fonction, Fonction,
Méthode, Transition, Action, Propriété.
Tous nœuds me lisant ou
m'écrivant
Ajoute au graphe les nœud qui lisent ou écrivent la propriété ou la
variable sélectionnée.
Ajouter un nœud de type
de données
Ajoute au graphe le nœud de type de données de la propriété ou
de la variable sélectionnée, à condition que ce type ne soit pas un
type de base (BOOL, REAL, STRING, etc.).
Ajouter mon parent
Peut être exécutée sur tous les nœuds, sauf Application et
Bibliothèque.
Ajouter mon type de retour
Ajoute au graphe le nœud de type de retour de la fonction ou de la
méthode sélectionnée, à condition que ce type ne soit pas un type
de base (BOOL, REAL, STRING, etc.).
Ajouter TestManager qui
m'exécute
Ajoute l'élément TestManager qui exécute l'élément TestCase
sélectionné.
Ajouter TestCases Je suis
en train d'exécuter
Ajoute les éléments TestCases exécutés par l'élément
TestManager sélectionné.
Ajouter Structures que
j'utilise
Ajoute les structures utilisées pour l'exécution de l'élément
TestCase sélectionné.
Ajouter TestCases que
j'utilise
Ajoute les éléments TestCases qui m'utilisent comme structure
pour l'exécution.
Ajouter TestCases et
TestResources qui
m'utilisent
Ajoute les éléments TestCases et TestResources qui utilisent
l'élément TestResource ou TestCase sélectionné.
Ajouter TestSets et
TestResources J'utilise
Ajoute les éléments TestCases et TestResources utilisés par
l'élément TestResource ou TestCase sélectionné.
Vue de dépendance (groupes)
Présentation
Les objets d'un graphe de dépendance peuvent être affectés à des groupes, qui
peuvent représenter des modules réels de la machine ou autres.
Informations à prendre en compte :
EIO0000004079.02
23
Machine Code Analysis
Éditeurs d'analyse de code
•
Les objets à affecter à un groupe doivent appartenir à la même application
que l'objet Vue de dépendance.
•
En affectant un bloc fonction ou un programme à un groupe, vous affectez
également les méthodes, actions, propriétés et transitions de l'objet au
groupe. Ces éléments s'affichent dans l'arborescence Groupes en tant que
sous-nœuds du bloc fonction ou du programme.
Barre d'outils
Elément
Description
Créer
Cliquez sur ce bouton pour créer un groupe vide.
Vous pouvez commencer à renommer un groupe en
sélectionnant un groupe dans l'arborescence et en cliquant sur
la touche ESPACE.
Supprimer
Cliquez sur ce bouton pour supprimer le groupe sélectionné.
Ouvrir Wizard
Cliquez sur ce bouton pour ouvrir le Wizard Groupes.
Affectation d'objets à des groupes
Il existe plusieurs manières d'affecter des objets à des groupes :
Elément
Description
Glisser-déposer
Les nœuds et les sous-nœuds d'un objet Application peuvent
être affectés à un groupe par glisser-déposer. Lorsque vous
faites glisser un dossier, ses sous-nœuds sont affectés au
groupe (une invite de confirmation s'affiche).
Menu contextuel de
l'arborescence Application
Les nœuds et les sous-nœuds d'un objet Application peuvent
être affectés à un groupe à l'aide de la commande de menu
contextuel, page 38 Ajouter au groupe.
Menu contextuel du graphe de
dépendance de la Vue de
dépendance
Le ou les éléments sélectionnés dans le graphe de
dépendance peuvent être affectés à un groupe nouveau ou
existant à l'aide de la commande de menu contextuel, page 38
Ajouter au graphe de dépendance.
Wizard Groupes
Le Wizard Groupes permet de créer des groupes et de leur affecter des objets à
partir d'une recherche sur le nom. Ce Wizard offre la possibilité de filtrer les objets
pouvant être affectés à des groupes nouveaux ou existants.
Elément
Description
Filtre de nom d'objet
Saisissez un texte simple ou une expression régulière (Regex)
afin de filtrer les objets de l'application à ajouter à un groupe.
Le filtre ne s'applique pas aux dossiers.
Exemples d'expressions Regex :
Filtre de type d'objet
•
[0-9] : filtre les objets dont le nom ne comporte aucun
chiffre.
•
[ _ ] : filtre les objets dont le nom ne comporte aucun trait
de soulignement.
Cochez les cases pour afficher moins d'objets.
La recherche par nom peut être limitée à certains types
d'objets :
Afficher uniquement les objets
non assignés
•
Bloc fonctionnel
•
Programme
Cochez cette case pour afficher uniquement les objets non
affectés à un groupe. Décochez-la pour afficher également les
objets déjà affectés.
Cette case est cochée par défaut.
24
EIO0000004079.02
Éditeurs d'analyse de code
Machine Code Analysis
Elément
Description
Nom de groupe
Une suggestion de nom de module est générée sur la base du
nom d'objet. Elle peut être modifiée à l'aide d'une expression
régulière (Regex) ou d'un nom explicite. Les noms de groupe
existants sont répertoriés dans la liste. Lorsque ce champ n'est
pas renseigné, le nom de projet d'origine s'applique.
Afficher la structure du
dossier
Cochez cette case pour afficher les objets dans la structure du
dossier.
Cette case est cochée par défaut.
Colonne Nom
Cochez les cases en regard des noms pour sélectionner les
objets à ajouter au groupe.
Lorsque vous sélectionnez un objet avec des sous-nœuds, les
cases de ces sous-nœuds sont également cochées. Le nom de
groupe des sous-nœuds est remplacé par celui du nœud
principal.
Colonne Nom de groupe
Pour modifier un nom de groupe suggéré, sélectionnez-le et
appuyez sur la barre d'espace.
Créer
Cliquez sur ce bouton pour créer un groupe à partir des objets
sélectionnés.
BlockList
Liste de blocage
Présentation
A BlockList object can be added beneath a Code Analysis Manager object. The
BlockList object contains elements that will not appear in Conventions Table,
Metrics Table, or Dashboard results. This, although, is taken into account when
you upload a project snapshot, page 29 into Machine Advisor Code Analysis.
Pour ajouter un élément à une liste de blocage, cliquez dessus avec le bouton
droit de la souris dans l'arborescence du navigateur et sélectionnez Analyse de
code > Ajouter à la liste de blocage > Ajouter aux utilisateurs-BlockList ou
Ajouter à Projet-BlockList dans le menu contextuel. Ces commandes de menu
contextuel sont également disponibles dans les listes de résultats du Tableau des
conventions ou du Tableau des mesures.
L'éditeur BlockList contient deux onglets :
•
Conventions
Liste des objets ne devant pas figurer dans les résultats du Tableau des
conventions et du Tableau de bord.
•
Métriques
Liste des objets ne devant pas figurer dans les résultats du Tableau des
mesures et du Tableau de bord.
Chaque onglet se divise en deux parties :
•
Projet Blocklist (à gauche)
Contient les éléments bloqués qui sont disponibles pour tous les utilisateurs
du projet.
•
Utilisateurs Blocklist (à droite)
Contient les éléments bloqués qui doivent être disponibles uniquement sur
votre ordinateur pour ce projet.
EIO0000004079.02
25
Machine Code Analysis
Éditeurs d'analyse de code
Éléments de la liste de blocage
Elément
Description
Élément
Icône et nom de l'élément bloqué.
Commentaire
Commentaire à propos de l'élément bloqué.
Sélectionnez la cellule de commentaire et appuyez sur la barre
d'espace pour ajouter ou modifier un commentaire.
Chemin
Chemin de l'élément bloqué.
Double-cliquez sur le chemin pour ouvrir l'objet associé dans
l'éditeur correspondant.
Commandes du menu
contextuel d'une entrée de
tableau
Cliquez avec le bouton droit de la souris sur une entrée du
tableau, puis sélectionnez l'une des commandes suivantes
dans le menu contextuel :
•
Atteindre la définition
Ouvre l'élément associé dans l'éditeur correspondant.
•
Supprimer de la liste de blocage
Supprime l'élément de la liste de blocage.
Double-clic sur une entrée du
tableau
26
Ouvre l'élément associé dans l'éditeur correspondant.
EIO0000004079.02
Gestionnaire d'analyse de code
Machine Code Analysis
Gestionnaire d'analyse de code
Tableau de bord
Présentation
The Dashboard provides an application overview.
L'onglet Tableau de bord se divise en quatre parties :
•
Barre d'outils
Informations d'horodatage de l'analyse du code.
Si le modèle de dépendance est obsolète, une notification s'affiche dans la
barre d'outils et l'analyse peut être relancée à l'aide du bouton Analyser le
code. Le bouton Vérifier les conventions permet d'analyser également les
conventions.
•
Filtre (à gauche)
Vous pouvez filtrer le contenu du Tableau de bord en fonction de types
d'objets.
By default, all object types are selected. If you modify the filter, the content of
the whole dashboard is updated in real time. The (<Number>) behind an
object type indicates the total number of objects per type that are included in
the code analysis. All object types are included.
•
Métriques (partie supérieure de la fenêtre principale)
Affiche les métriques les plus pertinentes en fonction du filtre appliqué.
•
Conventions (partie inférieure de la fenêtre principale)
Affiche le nombre de violations de code (nombre total, avertissements,
erreurs, informations).
Métriques
Affiche les métriques les plus pertinentes en fonction du filtre appliqué.
Element
Description
Lines of Code Total
Total sum of code lines for the objects.
Lines of Code Average
Lines of Code Total divided by the number of objects with lines
of code.
Halstead Difficulty Max
The maximum value of Halstead Difficulty.
Halstead Difficulty Average
The sum of the Halstead Difficulty values divided by the number
of objects.
Displays n/a if the applied filter contains no objects with a
Halstead Difficulty value.
Below the metrics, two bar charts are displayed:
•
Lines of Code Top 5
Displays the 5 objects with the highest Lines of Code value.
•
Halstead Difficulty Top 5
Displays the 5 objects with the highest Halstead Difficulty value.
The objects displayed in a bar chart provide additional information via tooltip.
Conventions
When the code analysis process is finished, the following is displayed:
•
EIO0000004079.02
A bar chart with the five objects that contain the highest number of code
convention violations.
27
Machine Code Analysis
Gestionnaire d'analyse de code
Each object displayed in the bar chart provides additional information via
tooltip.
•
The total number of code violations.
•
The total number of code violations with severity Error.
•
The total number of code violations with severity Warning.
•
The total number of code violations with severity Info.
Le graphique avec les cinq objets contenant le plus grand nombre de violations de
convention de code et le Tableau des conventions ne comportent pas les
mêmes éléments. Le Tableau de bord résume les violations au niveau du POU,
alors que le Tableau des conventions les détaille.
Informations du Tableau de bord enregistrées avec le projet
Les informations du Tableau de bord sont enregistrées avec votre projet. Elles
s'affichent à la prochaine ouverture du projet. Leurs données d'horodatage sont
indiquées sous Date/heure de la dernière analyse.
Configuration
Présentation
Une fois que vous avez ajouté un objet Gestionnaire d'analyse de code, une
configuration par défaut prenant en charge les principaux cas d'utilisation est
appliquée. Dans des cas bien spécifiques, vous pouvez modifier la profondeur de
l'analyse de code en fonction de vos exigences.
Utilisez les cases à cocher pour définir le contenu à analyser.
Elément
Description
Envisager des méthodes implicites
Cette option est désactivée par défaut.
Une fois l'option activée, les méthodes implicites générées (comme FB_INIT, FB_EXIT et FB_
REINIT) sont prises en compte lors de l'analyse du code.
Le plus souvent, ces méthodes ne permettent pas d'explorer le code source ou ne peuvent pas
être ajoutées à la liste des métriques et des conventions.
Désactivez cette option pour limiter la quantité de données d'analyse et améliorer les
performances.
Considérer les fonctions
d'accessibilité des propriétés
Cette option est désactivée par défaut.
Une fois l'option activée, les fonctions d'accessibilité des propriétés générées (comme
GetTextProperty(), GetBooleanProperty(), GetNumberProperty(), GetCompany(),
GetTextProperty2(), GetTitle(), GetVersion() et GetVersionProperty()) sont prises en compte
lors de l'analyse du code.
Le plus souvent, ces fonctions ne permettent pas d'explorer le code source ou ne peuvent pas
être ajoutées à la liste des métriques et des conventions.
Désactivez cette option pour limiter la quantité de données d'analyse, améliorer les
performances et faciliter l'utilisation du contenu de la Vue de dépendance ajouté via une
requête de sélection.
Considérer les fonctions de
vérification
Cette option est désactivée par défaut.
Une fois l'option activée, les fonctions de vérification (comme CheckBounds(), CheckDiv…() et
CheckPointer()) sont prises en compte lors de l'analyse du code.
Le plus souvent, ces fonctions ne permettent pas d'explorer le code source ou ne peuvent pas
être ajoutées à la liste des métriques et des conventions. Cette option permet de limiter la
quantité de données d'analyse, d'améliorer les performances et de faciliter l'utilisation de la
Vue de dépendance.
Envisager l'analyse du code des
bibliothèques en profondeur
Cette option est désactivée par défaut.
Plus le nombre de bibliothèques référencées (directement ou indirectement) et utilisées dans
un projet est élevé, plus vous aurez de résultats compilés à analyser.
28
EIO0000004079.02
Gestionnaire d'analyse de code
Machine Code Analysis
Elément
Description
En général, les fonctions, les programmes, les blocs fonction et autres objets qui interviennent
dans la compilation (parce qu'ils sont appelés, lus, écrits, etc.) sont intégrés dans les résultats
compilés peu importe leur origine (application, bibliothèque, espace POU, etc.).
Cela nécessite du temps processeur pendant l'analyse de code et aboutit à un modèle de
données plus volumineux.
Si vous activez cette option, un projet de taille moyenne comportant un grand nombre de
bibliothèques référencées peut utiliser plusieurs giga-octets de RAM (entre 8 et 12 Go). Par
ailleurs, l'opération de calcul pour analyser les dépendances de lecture, d'écriture et d'appel
entre les bibliothèques prendra plus de temps.
Vous risquez également de dépasser les délais d'exécution impartis pour obtenir les résultats
des conventions et des métriques.
Le plus souvent, le contenu d'une bibliothèque (qui n'est pas directement utilisée par
l'application via un appel, ou une opération de lecture ou d'écriture) peut être ignoré lors de
l'analyse du code.
Désactivez cette option pour limiter la quantité de RAM requise.
Considérer les périphériques
Cette option est désactivée par défaut.
Lorsque cette option est activée, tous les équipements sont pris en compte lors de l'analyse du
code. L'analyse des équipements ne permet pas d'obtenir des conventions ni des métriques.
Elle ne convient pas non plus pour explorer vos fonctions, programmes, blocs fonction et
autres objets via la Vue de dépendance. Si vous souhaitez analyser le lien entre ces objets et
les équipements ainsi que leurs paramètres, vous devez également considérer les
équipements.
NOTE: La quantité de RAM supplémentaire requise dépend du nombre d'équipements
dans le projet.
Cette option est généralement pertinente pour faire glisser un équipement dans la Vue de
dépendance, par exemple pour accéder à son instance de bloc fonction et identifier les
programmes ou fonctions qui accèdent directement à ses paramètres.
Prendre en compte le code et la taille
des données (génération de code
requise)
Cette option est désactivée par défaut. La génération de ces données nécessite de générer du
code et augmente le temps de création du modèle de données.
Si vous activez cette option, les métriques Taille de l'application (code), Taille de l'application
(code+données) et Taille de l'application (données) fournissent des résultats.
Connexion au cloud
Présentation
Cette option vous permet de télécharger le modèle d'analyse (snapshot) sur le
cloud Machine Advisor Code Analysis.
Connexion au cloud d'analyse de code
Etape
Action
1
Ouvrez l'onglet Connexion au cloud.
2
Cliquez sur le bouton Connexion.
Si vous n'avez pas de compte, suivez les instructions fournies dans le guide de
l'utilisateur de EcoStruxure Machine Advisor Code Analysis (voir EcoStruxure,
Machine Advisor Code Analysis, Guide de l'utilisateur.
Contexte de cloud d'analyse de code
Une fois connecté, procédez comme suit :
EIO0000004079.02
29
Machine Code Analysis
Gestionnaire d'analyse de code
Etape
Action
1
Cliquez dans le champ Société, puis sélectionnez la société pour laquelle le snapshot
doit être téléchargé.
2
Cliquez dans le champ Projet d'analyse, puis sélectionnez le projet dans lequel le
snapshot doit être téléchargé.
Téléchargement du snapshot
Le snapshot n'est pas créé par défaut.
Si le snapshot n'est pas disponible ou est obsolète, procédez comme suit :
Etape
Action
1
Cliquez sur le bouton Analyser le projet pour créer un snapshot.
2
Cliquez sur le bouton approprié pour télécharger le snapshot ou stocker le snapshot
dans le système de fichiers.
Le snapshot stocké dans le système de fichiers peut être téléchargé
manuellement (voir EcoStruxure, Machine Advisor Code Analysis, Guide de
l'utilisateur).
30
EIO0000004079.02
Gestionnaire de requêtes d'analyse de code
Machine Code Analysis
Gestionnaire de requêtes d'analyse de code
Présentation
Le Code Analysis Query Manager fournit des onglets permettant de créer et
modifier des jeux de règles personnalisés et de gérer vos requêtes de métriques
et de conventions.
Pour ouvrir le Code Analysis Query Manager cliquez sur Outils dans la barre de
menus et sélectionnez Code Analysis Query Manager dans le menu contextuel.
Rule Sets
Présentation
La fonctionnalité Rule Sets vous permet de fournir un sous-ensemble de requêtes
à utiliser pour analyser le projet. Vous pouvez utiliser des jeux de règles prédéfinis
comme modèles pour créer vos propres jeux de règles et les modifier selon vos
besoins. Vos nouveaux jeux de règles peuvent également être synchronisés avec
Machine Advisor Code Analysis.
La fenêtre principale de la fonctionnalité Rule Sets comprend deux parties :
•
Liste de jeux de règles
•
Requêtes affectées aux divers jeux de règles.
Liste de jeux de règles
La liste de jeux de règles affiche les jeux de règles prédéfinis (installés avec
EcoStruxure Machine Expert) et les jeux de règles définis par l'utilisateur.
Elément
Description
Nom
Nom du jeu de règles.
Affectations
Nombre d'affectation
Etat de synchronisation
Statut de la synchronisation avec EcoStruxure Machine Advisor
Code Analysis.
L'état de synchronisation est visible uniquement si vous êtes
connecté à Machine Advisor Code Analysis.
Barre d'outils
Elément
Description
Nouveau
Cliquez sur ce bouton pour créer un jeu de règles défini par
l'utilisateur et entrer son nom.
Dupliquer
Cliquez sur ce bouton pour dupliquer un jeu de règles
sélectionné et entrer le nom du nouveau jeu de règles.
Supprimer
Cliquez sur ce bouton pour supprimer un jeu de règles
sélectionné. Une invite de confirmation s'affiche. Confirmez en
cliquant sur Oui ou annulez en cliquant sur Non.
Restaurer
Cliquez sur ce bouton pour restaurer un jeu de règles
sélectionné. Une invite de confirmation s'affiche. Confirmez en
cliquant sur Oui ou annulez en cliquant sur Non.
Si vous confirmez, le jeu de règles personnalisé retourne à
l'état du modèle d'origine utilisé pour la personnalisation.
Actualiser
EIO0000004079.02
Cliquez sur ce bouton pour lancer la comparaison des jeux de
règles entre EcoStruxure Machine Expert et Machine Advisor
Code Analysis.
31
Machine Code Analysis
Gestionnaire de requêtes d'analyse de code
Elément
Description
Si EcoStruxure Machine Expert n'est pas connecté à Machine
Advisor Code Analysis, l'onglet Connexion au cloud s'ouvre
pour vous inviter à saisir vos informations d'identification.
Téléchargement manquant
Cliquez sur ce bouton pour télécharger tous les jeux de règles
de Machine Advisor Code Analysis qui ne sont pas disponibles
dans EcoStruxure Machine Expert.
Si EcoStruxure Machine Expert n'est pas connecté à Machine
Advisor Code Analysis, l'onglet Connexion au cloud s'ouvre
pour vous inviter à saisir vos informations d'identification.
Télécharger la sélection
Cliquez sur ce bouton pour télécharger les jeux de règles
sélectionnés de Machine Advisor Code Analysis vers
EcoStruxure Machine Expert.
Si EcoStruxure Machine Expert n'est pas connecté à Machine
Advisor Code Analysis, l'onglet Connexion au cloud s'ouvre
pour vous inviter à saisir vos informations d'identification.
Téléchargement sélectionné
Cliquez sur ce bouton pour envoyer et mettre à jour les jeux de
règles sélectionnés vers Machine Advisor Code Analysis.
Si EcoStruxure Machine Expert n'est pas connecté à Machine
Advisor Code Analysis, l'onglet Connexion au cloud s'ouvre
pour vous inviter à saisir vos informations d'identification.
Détails du jeu de règles sélectionné
Elément
Description
Nom
Nom du jeu de règles.
Description
Description détaillée du jeu de règles.
Chaînes de requête attribuées
L'arborescence Chaînes de requête attribuées affiche les
chaînes de requête de métriques et de conventions
disponibles.
Vous pouvez ajouter ou supprimer des chaînes de requête
dans le jeu de règles en activant/désactivant les cases à cocher
correspondant aux chaînes de requête appropriées.
Cliquez sur Récapitulatif (dans le coin supérieur droit) pour
ouvrir un fichier texte qui indique les chaînes de requête
attribuées au jeu de règles. Vous pouvez enregistrer ce fichier
pour votre usage.
Référentiels de requêtes
Présentation
Cette description générique est valable pour les référentiels suivants :
•
Métriques
•
Conventions
•
Requêtes de dépendance (filtre)
•
Requêtes de dépendance (sélection)
Pour plus d'informations, consultez les chapitres correspondants.
Vous pouvez créer des requêtes et des chaînes de requête, et les organiser, pour
toutes les catégories de référentiels. Une chaîne de requête se compose d'une ou
plusieurs requêtes.
Chaque référentiel propose une liste de requêtes et de chaînes de requête
prédéfinies dont l'utilisateur peut se servir comme modèles pour créer ses propres
requêtes ou chaînes de requête. Il est également possible de modifier directement
les requêtes et chaînes de requête prédéfinies.
32
EIO0000004079.02
Gestionnaire de requêtes d'analyse de code
Machine Code Analysis
La fenêtre principale d'un référentiel se divise en trois parties :
•
Chaînes de requêtes (à gauche)
Liste des chaînes de requête disponibles. Pour les métriques et les
conventions, le statut de synchronisation avec Machine Advisor Code
Analysis est fourni.
•
Requêtes (à droite)
Liste des requêtes disponibles.
•
Résultats (en bas)
Résultats pour la chaîne de requête sélectionnée et exécutée.
L'éditeur du référentiel situé tout à fait à droite correspond à l'Éditeur de
paramètres.
Chaînes de requêtes
L'arborescence Chaînes de requêtes contient les chaînes de requête disponibles
par défaut (avec l'installation d'EcoStruxure Machine Expert) ainsi que celles
définies par l'utilisateur à l'aide de l'Éditeur de paramètres de chaînes de
requête.
Les chaînes de requête prédéfinies fournies par Schneider Electric peuvent être
modifiées, mais aussi réinitialisées à leurs valeurs d'origine.
Barre d'outils
Elément
Description
Exécuter
Cliquez sur ce bouton pour exécuter la chaîne de requête
sélectionnée.
Le résultat s'affiche dans la fenêtre des résultats en bas de
l'écran.
Modifier
Cliquez sur ce bouton pour modifier la chaîne de requête
sélectionnée. Seules les chaînes de requête définies par
l'utilisateur sont modifiables. Le bouton Modifier permet
d'ouvrir l'Éditeur, page 36 Chaîne de requête.
Dupliquer
Cliquez sur ce bouton pour dupliquer la chaîne de requête
sélectionnée et attribuer un nom à la nouvelle chaîne. Doublecliquez sur la chaîne de requête dupliquée pour ouvrir l'Éditeur
de paramètres de chaînes de requête.
Nouveau
Cliquez sur ce bouton pour ajouter une chaîne de requête. Le
bouton Nouveau permet d'ouvrir l'Éditeur de paramètres de
chaînes de requête.
Supprimer
Cliquez sur ce bouton pour supprimer la chaîne de requête
sélectionnée.
Seules les chaînes de requête définies par l'utilisateur peuvent
être supprimées.
Restaurer
Cliquez sur ce bouton pour restaurer un jeu de règles
sélectionné. Une invite de confirmation s'affiche. Confirmez en
cliquant sur Oui ou annulez en cliquant sur Non.
Si vous confirmez, le jeu de règles personnalisé retourne à
l'état du modèle d'origine utilisé pour la personnalisation.
Actualiser
Cliquez sur ce bouton pour lancer la comparaison des jeux de
règles entre EcoStruxure Machine Expert et Machine Advisor
Code Analysis.
Si EcoStruxure Machine Expert n'est pas connecté à Machine
Advisor Code Analysis, l'onglet Connexion au cloud s'ouvre
pour vous inviter à saisir vos informations d'identification.
Téléchargement manquant
Cliquez sur ce bouton pour télécharger tous les jeux de règles
de Machine Advisor Code Analysis qui ne sont pas disponibles
dans EcoStruxure Machine Expert.
Si EcoStruxure Machine Expert n'est pas connecté à Machine
Advisor Code Analysis, l'onglet Connexion au cloud s'ouvre
pour vous inviter à saisir vos informations d'identification.
EIO0000004079.02
33
Machine Code Analysis
Gestionnaire de requêtes d'analyse de code
Elément
Description
Télécharger la sélection
Cliquez sur ce bouton pour télécharger les jeux de règles
sélectionnés de Machine Advisor Code Analysis vers
EcoStruxure Machine Expert.
Si EcoStruxure Machine Expert n'est pas connecté à Machine
Advisor Code Analysis, l'onglet Connexion au cloud s'ouvre
pour vous inviter à saisir vos informations d'identification.
Téléchargement sélectionné
Cliquez sur ce bouton pour envoyer et mettre à jour les jeux de
règles sélectionnés vers Machine Advisor Code Analysis.
Si EcoStruxure Machine Expert n'est pas connecté à Machine
Advisor Code Analysis, l'onglet Connexion au cloud s'ouvre
pour vous inviter à saisir vos informations d'identification.
Affecter des requêtes à des chaînes et les organiser
Elément
Description
Boutons fléchés
Les boutons fléchés entre les listes Chaînes de requête et
Requêtes permettent d'ajouter une requête à la chaîne de
requête sélectionnée ou de supprimer une requête. Vous
pouvez également les utiliser pour modifier l'ordre des requêtes
dans la chaîne sélectionnée.
Seules les chaînes de requête définies par l'utilisateur sont
modifiables.
Glisser-déposer
Vous pouvez également utiliser la méthode glisser-déposer
pour ajouter ou supprimer une requête pour une chaîne de
requête définie par l'utilisateur.
Requêtes
La liste Requêtes répertorie les requêtes disponibles par défaut (avec l'installation
d'EcoStruxure Machine Expert) ainsi que celles définies par l'utilisateur.
Les requêtes prédéfinies ne peuvent pas être supprimées ni modifiées. Vous
pouvez seulement les dupliquer.
Barre d'outils
Elément
Description
Modifier
Cliquez sur ce bouton pour modifier la requête sélectionnée.
Seules les requêtes définies par l'utilisateur sont modifiables.
Le bouton Modifier permet d'ouvrir l'Éditeur, page 35
Requête.
Dupliquer
Cliquez sur ce bouton pour dupliquer la requête sélectionnée et
attribuer un nom à la nouvelle requête. Double-cliquez sur la
requête dupliquée pour ouvrir l'Éditeur de requêtes.
Nouveau
Cliquez sur ce bouton pour ajouter une requête. Le bouton
Nouveau permet d'ouvrir l'Éditeur de requêtes.
Supprimer
Cliquez sur ce bouton pour supprimer la requête sélectionnée.
Seules les requêtes définies par l'utilisateur peuvent être
supprimées.
Restaurer
Cliquez sur ce bouton pour restaurer une requête sélectionnée.
Une invite de confirmation s'affiche. Confirmez en cliquant sur
Oui ou annulez en cliquant sur Non.
Si vous confirmez, la requête personnalisée retourne à l'état de
la requête d'origine.
Éditeur de paramètres
L'Éditeur de paramètres contient les paramètres de la requête ou de la chaîne
de requête sélectionnée.
34
EIO0000004079.02
Gestionnaire de requêtes d'analyse de code
Machine Code Analysis
Consultez la section Éditeur de paramètres.
Éditeur de requêtes
Présentation
L'Éditeur de requêtes vous permet de modifier ou de créer des requêtes définies
par l'utilisateur.
La fenêtre principale de l'Éditeur de requêtes se divise en deux parties :
•
Éditeur SPARQL
•
Résultats requête
L'Éditeur de paramètres s'affiche tout à fait à droite de l'Éditeur de requêtes.
Éditeur SPARQL
Elément
Description
Name
Modifiez le nom de la requête
Éditeur SPARQL
Modifiez la requête SPARQL.
Messages de validation de la
syntaxe
Les erreurs de syntaxe SPARQL détectées sont indiquées en
bas de l'Éditeur de requêtes. Cliquez sur un message pour
accéder à l'erreur correspondante dans l'Éditeur de requêtes.
Elément
Description
Chaîne de requête
Une requête ne peut être exécutée que dans une chaîne de
requête. Lorsqu'elle est déjà affectée à des chaînes de requête,
celles-ci apparaissent dans la liste. La liste propose également
une chaîne de requête par défaut sans paramètres.
Résultats requête
Les résultats de la requête s'affichent dans le tableau
Résultats requête.
Case à cocher Exécuter
Décochez cette case pour désactiver l'exécution automatique
de la requête.
Bouton Exécuter
Cliquez sur ce bouton pour forcer l'exécution.
Résultats requête
EIO0000004079.02
35
Machine Code Analysis
Gestionnaire de requêtes d'analyse de code
Éditeur de paramètres
L'Éditeur de paramètres contient les paramètres de la requête.
Consultez la section Éditeur de paramètres.
Éditeur de paramètres de chaînes de requête
Présentation
L'Éditeur de paramètres de chaînes de requête vous permet de configurer des
chaînes de requête définies par l'utilisateur.
Les paramètres disponibles dépendent du référentiel auquel appartient la requête.
Elément
Description
Disponibilité
Description
Description de la chaîne de
requête.
Tous les onglets de requête
Groupe
Définit le nom du groupe dans
lequel les requêtes doivent
s'afficher.
•
Requêtes de dépendance
(sélection)
Ce groupe figure dans la boîte
de dialogue Sélectionner et
ajouter de l'éditeur Vue de
dépendance.
•
Requêtes de convention
Ce groupe figure dans
l'arborescence Conventions
de l'éditeur Tableau des
conventions.
Code de couleurs
Un code de couleurs est disponible pour les requêtes de métrique.
Il est possible de surligner des résultats particuliers concernant les métriques à
l'aide de couleurs dans le Tableau des mesures.
Les règles en matière de code de couleurs reposent sur quatre paramètres :
36
Paramètre
Description
Valeur
Saisissez la valeur à laquelle le résultat de requête de métrique réel
est comparé.
Comparer
Sélectionnez l'opérateur de comparaison des résultats de requête
de métrique.
•
GT (>)
•
LT (<)
•
GTE (≥)
•
LTE (≤)
•
EQ (=)
•
NEQ (≠)
Type de comparaison
Saisissez une valeur fixe ou un pourcentage. 100 % correspond à la
valeur la plus élevée pour cette requête de métrique.
Couleur
Saisissez la valeur hexadécimale de la couleur dans laquelle le
résultat de la requête de métrique doit s'afficher lorsque la règle est
respectée.
EIO0000004079.02
Gestionnaire de requêtes d'analyse de code
Machine Code Analysis
Éditeur de paramètres
Présentation
L'Éditeur de paramètres vous permet :
•
d'afficher les paramètres de la requête ou de la chaîne de requête
sélectionnée ;
•
d'ajouter et de supprimer des paramètres ;
•
de modifier le nom, la valeur et le type des paramètres associés aux
requêtes ou aux chaînes de requête définies par l'utilisateur.
Elément
Description
Nom
Nom de la variable
Valeur
Valeur par défaut
Type
Types de variables disponibles :
•
Booléen
•
Int32
•
Double
•
Chaîne
Ajouter
Cliquez sur ce bouton pour ajouter un paramètre.
Supprimer
Cliquez sur ce bouton pour supprimer le paramètre sélectionné.
Connexion au cloud
Présentation
Cette option vous permet de télécharger votre modèle d'analyse (snapshot) vers
l'application Web Machine Advisor Code Analysis.
Connexion au cloud d'analyse de code
Etape
Action
1
Ouvrez l'onglet Connexion au cloud.
2
Cliquez sur le bouton Connexion.
Si vous n'avez pas de compte, suivez les instructions fournies dans le guide de
l'utilisateur de EcoStruxure Machine Advisor Code Analysis (voir EcoStruxure,
Machine Advisor Code Analysis, Guide de l'utilisateur.
Contexte de cloud d'analyse de code
Si vous avez réussi à vous connecter, cliquez dans le champ Société et
sélectionnez la société dans laquelle le snapshot doit être téléchargé.
Synchronisation des requêtes
Pour vérifier si les requêtes de votre ordinateur et de Machine Advisor Code
Analysis sont identiques, cliquez sur le bouton Comparer les requêtes.
Si tel n'est pas le cas, le bouton Envoyer toutes les requêtes vous permet de
télécharger vos requêtes dans Machine Advisor Code Analysis.
EIO0000004079.02
37
Machine Code Analysis
Commandes du menu contextuel
Commandes du menu contextuel
Commandes de menu contextuel des navigateurs
Présentation
Les commandes de menu contextuel suivantes sont disponibles pour tous les
objets d'analyse de code sous l'objet Application :
•
Tout nettoyer
•
Ajouter au groupe
•
Ajouter au graphe de dépendance
Tout nettoyer
Cette commande de menu contextuel permet de supprimer les données d'analyse
concernant l'application qui contient l'objet sélectionné.
Ajouter au groupe
Cette commande de menu contextuel permet d'ajouter l'objet sélectionné à un
groupe nouveau ou existant.
Ajouter au graphe de dépendance
Cette commande de menu contextuel permet d'ajouter l'objet sélectionné à un
graphe de dépendance nouveau ou existant.
Une fois le code analysé, la Vue de dépendance nouvelle ou existante s'ouvre et
les objets sélectionnés sont ajoutés au graphe de dépendance dans le coin
supérieur gauche.
Vous pouvez également ajouter des variables à un graphe de dépendance. Dans
votre code de programme, cliquez avec le bouton droit sur une variable et
sélectionnez Analyse de code > Ajouter au graphe de dépendance dans le
menu contextuel.
38
EIO0000004079.02
Instructions Pragma pour Machine Code Analysis
Machine Code Analysis
Instructions Pragma pour Machine Code Analysis
Instructions Pragma pour Machine Code Analysis
Présentation
L'auteur du code source peut utiliser des instructions Pragma pour décider si le
code doit être inclus dans l'analyse.
Les listes de blocage, elles, permettent d'exclure des éléments une fois l'analyse
exécutée. L'effet obtenu est identique.
Avec des instructions Pragma, vous pouvez :
•
marquer les éléments du code source (fonctions, programmes, blocs
fonction, variables, etc.) à ignorer lors de l'analyse du code (cas d'utilisation
1) ;
•
marquer les éléments du code source qui seront filtrés dans les résultats du
Tableau des conventions/Tableau des mesures ou dans la Vue de
dépendance (cas d'utilisation 2).
Voir également le chapitre BlockList, page 25.
Cas d'utilisation 1
Le code qui ne doit pas être analysé peut être marqué à l'aide de l'instruction
Pragma ignore. Les éléments ainsi marqués ne sont pas inclus dans le modèle
de données d'analyse.
Attribut
{attribute 'code_analyzer' :=
'ignore'}
attribute 'code_analyzer' := 'public_
only'}
Description
•
Marque un POU ou une variable à ignorer.
•
Fonctionne en mode récursif (par
exemple, les variables du POU ou les
méthodes d'un bloc fonction sont
également ignorées).
•
Priorité maximale (comparé à l'attribut
'public_only').
•
Marque un POU pour tenir compte
uniquement des éléments publics (VarIn,
VarOut, VarInOut, propriétés publiques,
méthodes publiques). Les autres
éléments sont ignorés.
•
Fonctionne en mode récursif (par
exemple, les méthodes d'un bloc fonction
sont traitées comme le bloc fonction).
Cas d'utilisation 2
Le code non modifiable qui apparaît dans les résultats associés aux conventions
et/ou aux métriques peut être marqué afin d'être masqué dans ces listes.
Attribut
{attribute 'code_analysis_ui' :=
'filter_in_results'}
{attribute 'code_analysis_ui' :=
'filter_in_conventions'}
EIO0000004079.02
Description
•
Marque un POU ou une variable comme
étant à filtrer dans les résultats (Tableau
des conventions, Tableau des mesures
et Vue de dépendance).
•
Fonctionne en mode non récursif.
•
Marque un POU ou une variable comme
étant à filtrer dans les résultats du
Tableau des conventions (via l'interface
utilisateur ou l'API de création de scripts).
•
Fonctionne en mode non récursif.
39
Machine Code Analysis
Instructions Pragma pour Machine Code Analysis
Attribut
{attribute 'code_analysis_ui' :=
'filter_in_metrics'}
{attribute 'code_analysis_ui' :=
'filter_in_dependency_view'}
Description
•
Marque un POU ou une variable comme
étant à filtrer dans les résultats du
Tableau des mesures (via l'interface
utilisateur ou l'API de création de scripts).
•
Fonctionne en mode non récursif.
•
Marque un POU ou une variable comme
étant à filtrer dans la Vue de dépendance
(boîte de dialogue Sélectionner et
ajouter).
•
Fonctionne en mode non récursif.
Exemples
Ignorer une variable publique
METHOD PUBLIC PublicMethod
VAR_INPUT
{attribute 'code_analyzer' := 'ignore'}
i_iPublicButIgnoredVar: INT;
i_iPublicVar2: INT;
END_VAR
VAR
iPrivateVar2: INT;
END_VAR
Tenir compte des éléments publics uniquement
{attribute 'code_analyzer' := 'public_only'}
FUNCTION_BLOCK FB_PublicOnlyTest1
VAR_INPUT
i_iPublicVar: INT;
END_VAR
VAR
iPrivateVar: INT;
END_VAR
Filtrer (un POU) dans les résultats
{attribute 'code_analysis_ui' := 'filter_in_results'}
PROGRAM SR_FilterInResultsTest1
VAR
END_VAR
Filtrer (une variable) dans les résultats associés aux métriques et/ou aux
conventions
PROGRAM SR_FilterVars
VAR
{attribute 'code_analysis_ui' := 'filter_in_metrics'}
iTestVar1: INT;
{attribute 'code_analysis_ui' := 'filter_in_results'}
iTestVar2: INT;
{attribute 'code_analysis_ui' := 'filter_in_
conventions'}
FAILED_iTestVar3: INT;
END_VAR
40
EIO0000004079.02
Interface de création de scripts Python
Machine Code Analysis
Interface de création de scripts Python
Interface de création de scripts
Présentation
Une API de création de scripts est disponible afin d'automatiser l'analyse du code.
Elle vous permet d'intégrer cette analyse dans les environnements de gestion du
cycle de vie des applications (ALM) et d'intégration continue (CI).
Consultez également les rubriques suivantes de l'aide en ligne :
•
EcoStruxure Machine Expert - Guide de programmation\Annexes\Langage
de script Python (voir EcoStruxure Machine Expert, Programming Guide)
•
Référence d'API du plug-in Script Engine
•
Bibliothèque de classe Script Engine
Extensions des objets de script
Application
L'objet Application est étendu par la propriété suivante :
Propriété
Objet/valeur renvoyé(e)
Description
code_analysis
ScriptCodeAnalysis, avec
fonctions/propriétés associées
L'objet renvoyé permet d'accéder aux
fonctions d'analyse de code, comme
perform_full_analysis().
Consultez la section Objets de script
Python, page 42.
Tableau des conventions
L'objet Tableau des conventions est étendu par la fonction suivante :
Fonction
Objet/valeur renvoyé(e)
Description
conventions_table
()
ConventionsTableResults, avec fonctions/
propriétés associées
Grâce à l'appel de cette méthode,
l'analyse de code génère les résultats
concernant le Tableau des
conventions. L'objet renvoyé permet
d'accéder à ces résultats.
La convention configurée pour l'objet
Tableau des conventions est utilisée.
Consultez la section Objets de script
Python, page 42.
Tableau des mesures
L'objet Tableau des mesures est étendu par la fonction suivante :
EIO0000004079.02
41
Machine Code Analysis
Interface de création de scripts Python
Fonction
Objet/valeur renvoyé(e)
Description
metrics_table()
MetricsTableResults,
avec fonctions/propriétés
associées
Grâce à l'appel de cette méthode,
l'analyse de code génère les résultats
concernant le Tableau des mesures.
L'objet renvoyé permet d'accéder à
ces résultats.
La métrique configurée pour l'objet
Tableau des mesures est utilisée.
Consultez la section Objets de script
Python, page 42.
Objets de script (API d'analyse de code)
Présentation
Les extensions d'objets de script, page 41 permettent d'utiliser les objets de script
renvoyés pour déclencher une analyse du code ou consulter les résultats
concernant les conventions ou les métriques, par exemple.
API d'analyse de code
Cet objet offre un accès global à l'analyse de code d'un objet Application.
Propriété
Objet/valeur renvoyé(e)
Description
metrics
MetricsTable, avec
fonctions/propriétés associées
La propriété metrics permet
d'accéder à l'API de création de scripts
propre aux métriques.
conventions
ConventionsTable, avec
fonctions/propriétés associées
La propriété conventions permet
d'accéder à l'API de création de scripts
propre aux conventions.
configuration
Configuration, avec
fonctions/propriétés associées
La propriété configuration permet
d'accéder à l'API de création de scripts
propre à la configuration.
cloud_connection
CloudConnection, avec
fonctions/propriétés associées
La propriété cloud_connection
permet d'accéder au téléchargement
de snapshots vers les Triple Storages,
ainsi qu'à la configuration de la
connexion au cloud.
Fonctions
Objet/valeur renvoyé(e)
Description
clear()
Aucun(e)
Supprime le modèle de dépendance
en mémoire. Une autre analyse de
code peut être lancée.
perform_full_
analysis()
Aucun(e)
Démarre une analyse de code
complète. Le modèle de dépendance
est généré et réutilisé (par exemple,
par l'API de métriques).
store_dependency_
model(filename)
Aucun(e)
Stocke le modèle de dépendance dans
un fichier XML.
store_ttl
(filename)
Aucun(e)
Stocke le modèle RDF sur disque
dans un fichier TTL.
Le langage TTL (Turtle Language) est
un format standard de stockage des
modèles RDF défini par le W3C
(https://www.w3.org).
42
EIO0000004079.02
Interface de création de scripts Python
Machine Code Analysis
API de métriques
Fonctions
Objet/valeur renvoyé(e)
Description
get_all_metrics()
string[], avec noms des
métriques disponibles
Renvoie les noms des requêtes de
métrique disponibles.
full_metrics_
table()
MetricsTableResult, avec
fonctions/propriétés associées
Génère le Tableau des mesures à
partir des requêtes de métrique
disponibles. Consultez la section API
de résultats du Tableau des mesures.
metrics_table()
MetricsTableResult, avec
fonctions/propriétés associées
Génère le Tableau des mesures à
partir des requêtes de métrique
indiquées. Consultez la section API de
résultats du Tableau des mesures.
Propriétés
Objet/valeur renvoyé(e)
Description
successful
BOOL
Renvoie le résultat (réussite).
message
STRING
Renvoie le message de résultat lisible.
project_path
STRING
Renvoie le chemin du projet dont les
résultats proviennent.
analysis_started_
at
STRING
Renvoie l'heure de début du
processus de génération de ce tableau
de résultats.
analysis_
finished_at
STRING
Renvoie l'heure de fin du processus de
génération de ce tableau de résultats.
analyser_version
STRING
Renvoie la version de l'analyseur de
code qui a servi à générer ce tableau
de résultats.
columns
STRING
Renvoie la liste des colonnes de ce
tableau de résultats.
rows
STRING
Renvoie le tableau (lignes avec
colonnes : [Array] of [Array]) avec les
valeurs de résultat.
Fonctions
Objet/valeur renvoyé(e)
Description
store_as_xml(…)
Aucun(e)
Stocke les résultats du Tableau des
mesures sur disque dans un fichier
XML.
store_as_csv(…)
Aucun(e)
Stocke les résultats du Tableau des
mesures sur disque dans un fichier
CSV.
store_as_html(…)
Aucun(e)
Stocke les résultats du Tableau des
mesures sur disque dans un fichier
HTML.
API de résultats du Tableau des mesures
Indiquez un fichier XSLT pour convertir
le format XML en HTML, si besoin.
EIO0000004079.02
43
Machine Code Analysis
Interface de création de scripts Python
API de conventions
Fonctions
Objet/valeur renvoyé(e)
Description
get_all_
conventions()
STRING[], avec noms des
conventions disponibles
Renvoie les noms des requêtes de
conventions disponibles.
full_conventions_
table()
ConventionTableResult,
avec fonctions/propriétés
associées
Génère le Tableau des conventions à
partir des requêtes de convention
disponibles.
Consultez la section API de résultats
du Tableau des conventions.
conventions_table
()
ConventionTableResult,
avec fonctions/propriétés
associées
Génère le Tableau des conventions à
partir des requêtes de convention
indiquées.
Consultez la section API de résultats
du Tableau des conventions.
API de résultats du Tableau des conventions
Propriétés
Objet/valeur renvoyé(e)
Description
successful
BOOL
Renvoie le résultat (réussite).
message
STRING
Renvoie le message de résultat lisible.
project_path
STRING
Renvoie le chemin du projet dont les
résultats proviennent.
analysis_started_
at
STRING
Renvoie l'heure de début du
processus de génération de ce tableau
de résultats.
analysis_
finished_at
STRING
Renvoie l'heure de fin du processus de
génération de ce tableau de résultats.
analyser_version
STRING
Renvoie la version de l'analyseur de
code qui a servi à générer ce tableau
de résultats.
columns
STRING
Renvoie la liste des colonnes de ce
tableau de résultats.
rows
STRING
Renvoie le tableau (lignes avec
colonnes : [Array] of [Array]) avec les
valeurs de résultat.
Fonctions
Objet/valeur renvoyé(e)
Description
store_as_xml(…)
Aucun(e)
Stocke les résultats du Tableau des
conventions sur disque dans un fichier
XML.
store_as_csv(…)
Aucun(e)
Stocke les résultats du Tableau des
conventions sur disque dans un fichier
CSV.
store_as_html(…)
Aucun(e)
Stocke les résultats du Tableau des
conventions sur disque dans un fichier
HTML.
Indiquez un fichier XSLT pour convertir
le format XML en HTML, si besoin.
API de configuration
44
Propriété
Objet/valeur renvoyé(e)
Description
triple_storage_
backend_type
Énumération
TripleStorageBackendTypes
Configure le type de backend Triple
Storage RDF qui servira à gérer les
données d'analyse de code.
thresshold_for_
out_proc_backend_
usage
INT
Configure le seuil de sélection
automatique du type de backend de
stockage utilisé (en mémoire ou OutProc).
EIO0000004079.02
Interface de création de scripts Python
Machine Code Analysis
Propriété
Objet/valeur renvoyé(e)
Description
max_upload_
triple_count_per_
request
INT
Configure le nombre de triplets par
demande de téléchargement.
query_execution_
timeout
Long
Configure le timeout d'exécution des
requêtes.
update_execution_
timeout
Long
Configure le timeout d'exécution de la
mise à jour d'une requête.
server_uri
STRING
Configure l'URI de serveur des
backends de stockage HTTP.
relative_query_
endpoint
STRING
Configure le point final de requête pour
les backends de stockage HTTP (par
rapport à l'URL complète de point final
de requête).
relative_update_
endpoint
STRING
Configure le point final de mise à jour
pour les backends de stockage HTTP
(par rapport à l'URL complète de point
final de mise à jour).
dataset
STRING
Configure le nom du jeu de données
pour les backends de stockage HTTP
(par rapport à l'URL de point final).
relative_data_
endpoint
STRING
Configure le point final de données
pour les backends de stockage HTTP
(par rapport à l'URL de point final).
relative_sparql_
endpoint
STRING
Configure le point final SPARQL pour
les backends de stockage HTTP (par
rapport à l'URL de point final).
graph_name
STRING
Configure le nom du graphe pour les
backends de stockage HTTP (par
rapport à l'URL de point final).
sparql_endpoint
STRING
Lecture seule. Permet d'accéder à
l'URL complète de point final SPARQL.
data_endpoint
STRING
Lecture seule. Permet d'accéder à
l'URL complète de point final de
données.
query_endpoint
STRING
Lecture seule. Permet d'accéder à
l'URL complète de point final de
requête.
update_endpoint
STRING
Lecture seule. Permet d'accéder à
l'URL complète de point final de mise à
jour.
Fonctions
Objet/valeur renvoyé(e)
Description
reset()
Aucun(e)
Réinitialise la configuration de
l'analyse du code.
Propriété
Objet/valeur renvoyé(e)
Description
configuration
CloudConfiguration, avec
fonctions/propriétés associées
Permet d'accéder à l'API de création
de scripts propre à la configuration
cloud.
Fonctions
Objet/valeur renvoyé(e)
Description
upload_to_triple_
storage(…)
Aucun(e)
Démarre le téléchargement du
snapshot du modèle RDF dans le
Triple Storage RDF configuré.
API de connexion au cloud
EIO0000004079.02
45
Machine Code Analysis
Interface de création de scripts Python
API de configuration cloud
46
Propriété
Objet/valeur renvoyé(e)
Description
http_backend_type
Énumération
HttpBackendTypes
Configure le type de backend HTTP
(par exemple, générique, Apache
Fuseki, Stardog, etc.). Cette valeur est
prise en compte à condition que le
type de backend Triple Storage soit
défini sur « Http ».
max_upload_
triple_count_per_
request
Integer
Configure le nombre de triplets par
demande de téléchargement.
update_execution_
timeout
Long
Configure le timeout d'exécution de la
mise à jour d'une requête.
server_uri
String
Configure l'URI de serveur des
backends de stockage HTTP.
relative_query_
endpoint
String
Configure le point final de requête pour
les backends de stockage HTTP (par
rapport à l'URI complète de point final
de requête).
relative_update_
endpoint
String
Configure le point final de mise à jour
pour les backends de stockage HTTP
(par rapport à l'URI complète de point
final de mise à jour).
dataset
String
Configure le nom du jeu de données
pour les backends de stockage HTTP
(par rapport à l'URI de point final).
relative_data_
endpoint
String
Configure le point final de données
pour les backends de stockage HTTP
(par rapport à l'URI de point final).
relative_sparql_
endpoint
String
Configure le point final SPARQL pour
les backends de stockage HTTP (par
rapport à l'URI de point final).
sparql_endpoint
String
Lecture seule. Permet d'accéder à
l'URI complète de point final SPARQL.
data_endpoint
String
Lecture seule. Permet d'accéder à
l'URI complète de point final de
données.
query_endpoint
String
Lecture seule. Permet d'accéder à
l'URI complète de point final de
requête.
update_endpoint
String
Lecture seule. Permet d'accéder à
l'URI complète de point final de mise à
jour.
Fonctions
Objet/valeur renvoyé(e)
Description
reset()
Aucun(e)
Réinitialise la configuration cloud de
l'analyse du code.
EIO0000004079.02
Comment ajouter des éditeurs d'analyse de code
Machine Code Analysis
Comment ajouter des éditeurs d'analyse de code
Comment avoir un aperçu rapide de l'application via le Tableau de
bord
Présentation
The Dashboard provides an application overview.
Consultez la section Tableau de bord, page 27.
Ouverture ou création d'un projet
Open your preferred project or create a new project with File > New Project >
From Project Template > Template Full.
Ajout d'un Gestionnaire d'analyse de code
L'onglet Tableau de bord est accessible via le Gestionnaire d'analyse de code.
Votre première tâche consiste donc à ajouter un Gestionnaire d'analyse de
code à votre projet.
Etape
Action
Résultat /Commentaire
1
Cliquez avec le bouton droit de la souris
sur le nœud Application dans
l'arborescence Équipements.
-
2
Sélectionnez Ajouter objet >
Gestionnaire d'analyse de code dans le
menu contextuel.
L'éditeur Ajouter un Gestionnaire
d'analyse de code s'affiche.
3
Cliquez sur le bouton Ajouter.
•
Un objet Gestionnaire d'analyse de
code est ajouté sous l'objet
Application dans l'arborescence
Équipements.
•
L'onglet Tableau de bord du
Gestionnaire d'analyse de code
s'affiche.
Analyse du code
Etape
1
Action
Résultat /Commentaire
Cliquez sur le bouton Analyser le code
de l'onglet Tableau de bord.
Le projet est analysé et les métriques
s'affichent.
Si vous modifiez le filtre à gauche, tout le
contenu du Tableau de bord est mis à jour
en temps réel.
Résumé
Element
Description
Lines of Code Total
Total sum of code lines for the objects.
Lines of Code Average
Lines of Code Total divided by the number of objects with lines
of code.
Halstead Difficulty Max
The maximum value of Halstead Difficulty.
Halstead Difficulty Average
The sum of the Halstead Difficulty values divided by the number
of objects.
Displays n/a if the applied filter contains no objects with a
Halstead Difficulty value.
EIO0000004079.02
47
Machine Code Analysis
Comment ajouter des éditeurs d'analyse de code
Below the metrics, two bar charts are displayed:
•
Lines of Code Top 5
Displays the 5 objects with the highest Lines of Code value.
•
Halstead Difficulty Top 5
Displays the 5 objects with the highest Halstead Difficulty value.
The objects displayed in a bar chart provide additional information via tooltip.
Ajout de conventions
Etape
1
Action
Résultat /Commentaire
Pour ajouter plus de résultats, cliquez sur
le bouton Ajouter des conventions du
Tableau de bord.
Le projet est analysé (le processus peut
prendre du temps) et les résultats associés
aux conventions s'affichent.
Comment obtenir des résultats détaillés sur les métriques de
votre application
Présentation
With the Metrics Table, you can select metrics to be executed on an application
and filter and list results.
Consultez la section Tableau des mesures, page 18.
Ouverture ou création d'un projet
Open your preferred project or create a new project with File > New Project >
From Project Template > Template Full.
Ajout d'un Tableau des mesures
Etape
Action
Résultat /Commentaire
1
Cliquez avec le bouton droit de la souris
sur l'objet Application dans
l'arborescence Équipements.
-
2
Sélectionnez Ajouter objet > Tableau
des métriques d'analyse de code dans
le menu contextuel.
L'éditeur Ajouter l'objet de la table des
métriques d'analyse de code s'affiche.
3
Cliquez sur le bouton Ajouter.
•
Un objet Tableau des métriques
d'analyse de code est ajouté sous
l'objet Application dans
l'arborescence Équipements.
•
Le Tableau des mesures s'affiche.
Analyse du code
Etape
48
Action
Résultat /Commentaire
1
Dans la colonne Nom, décochez la case
Tout.
(Lorsque la case Tout est cochée, l'analyse
prend plus de temps).
2
Cochez les cases Halstead Difficulty et
Lines Of Code.
-
3
Cliquez sur le bouton Analyser le code.
Le projet est analysé et les résultats
s'affichent.
EIO0000004079.02
Comment ajouter des éditeurs d'analyse de code
Machine Code Analysis
Comment utiliser les résultats
Vous pouvez maintenant filtrer les résultats (comme les valeurs Halstead
Difficulty) en cliquant sur l'en-tête de colonne et examiner votre projet (en vous
concentrant sur les valeurs Halstead Difficulty les plus élevées, par exemple).
En double-cliquant sur une entrée du tableau, vous ouvrez l'objet d'application
associé dans l'éditeur correspondant. Vous pouvez également utiliser la
commande Atteindre la définition dans le menu contextuel d'une entrée du
tableau.
Pour les objets qui ne doivent pas s'afficher dans les résultats du Tableau des
mesures, vous pouvez utiliser la commande Ajouter à la liste de blocage du
menu contextuel d'une entrée du tableau.
Comment obtenir des résultats détaillés sur les conventions de
votre application
Présentation
With the Conventions Table, you can select conventions that have to be met by
your application.
Consultez la section Tableau des conventions, page 17.
Ouverture ou création d'un projet
Open your preferred project or create a new project with File > New Project >
From Project Template > Template Full.
Ajout d'un Tableau des conventions
Etape
Action
Résultat /Commentaire
1
Cliquez avec le bouton droit de la souris
sur l'objet Application dans
l'arborescence Équipements.
-
2
Sélectionnez Ajouter objet > Tableau
des conventions d'analyse de code
dans le menu contextuel.
L'éditeur Ajouter un objet de table des
conventions d'analyse de code s'affiche.
3
Cliquez sur le bouton Ajouter.
•
Un objet Tableau des conventions
d'analyse de code est ajouté sous
l'objet Application dans
l'arborescence Équipements.
•
Le Tableau des conventions
s'affiche.
Analyse du code
Etape
EIO0000004079.02
Action
Résultat /Commentaire
1
Dans la colonne Nom, décochez la case
Tout.
(Lorsque la case Tout est cochée, l'analyse
prend plus de temps).
2
Cochez la case Variable Name Checks
(Complex Types).
-
3
Cliquez sur le bouton Analyser le code.
Le projet est analysé et les résultats
s'affichent.
49
Machine Code Analysis
Comment ajouter des éditeurs d'analyse de code
Comment utiliser les résultats
Vous pouvez maintenant cocher la case Variable Name (Array) pour afficher les
résultats correspondants, par exemple. Examinez ensuite votre projet en vous
concentrant sur ces résultats associés aux conventions.
En double-cliquant sur une entrée du tableau, vous ouvrez l'objet d'application
associé dans l'éditeur correspondant. Vous pouvez également utiliser la
commande Atteindre la définition dans le menu contextuel d'une entrée du
tableau.
Pour les objets qui ne doivent pas s'afficher dans les résultats du Tableau des
conventions, vous pouvez utiliser la commande Ajouter à la liste de blocage du
menu contextuel d'une entrée du tableau.
Comment afficher les dépendances de votre application avec des
requêtes prédéfinies dans la vue de dépendance
Présentation
With the Dependency View, you can visualize the dependencies of your analyzed
application as a dependency graph. You can select the content and the layout of
the dependency graph.
Consultez la section Vue de dépendance, page 20.
Ouverture ou création d'un projet
Open your preferred project or create a new project with File > New Project >
From Project Template > Template Full.
Ajout d'une vue de dépendance
Etape
Action
Résultat /Commentaire
1
Cliquez avec le bouton droit de la souris
sur l'objet Application dans
l'arborescence Équipements.
-
2
Sélectionnez Ajouter objet > Vue de
dépendance d'analyse de code dans le
menu contextuel.
L'éditeur Ajouter l'objet de vue de
dépendance d'analyse de code s'affiche.
3
Cliquez sur le bouton Ajouter.
•
Un objet Vue de dépendance
d'analyse de code est ajouté sous
l'objet Application dans
l'arborescence Équipements.
•
La Vue de dépendance s'affiche.
Analyse du code
Etape
1
50
Action
Résultat /Commentaire
Cliquez sur le bouton Analyser le code.
Le projet est analysé.
EIO0000004079.02
Comment ajouter des éditeurs d'analyse de code
Machine Code Analysis
Sélection de la portée et de la requête
Etape
Action
Résultat /Commentaire
1
Cliquez sur le bouton Sélectionner et
ajouter.
-
2
Sélectionnez Scope
espace POU.
3
Sélectionnez la requête
4
Cliquez sur le bouton Appliquer.
> Application +
> Call Graph.
Cette option limite les éléments ajoutés au
graphe de dépendance aux nœuds définis
uniquement dans le projet.
Cette option ajoute les appels de
l'application au graphe de dépendance.
Le projet est analysé et le graphe de
dépendance s'affiche.
Comment explorer étape par étape les dépendances de votre
application dans la vue de dépendance
Présentation
Vous pouvez également ajouter des nœuds et des sous-nœuds dans le graphe de
dépendance par glisser-déposer.
Etape
Action
Résultat /Commentaire
1
Ajoutez une vue de dépendance au nœud
Application.
Voir ci-dessus.
2
Dans l'arborescence Équipements,
sélectionnez le nœud SR_MainMachine
(PRG).
Application >
TemplateFullProgrammingFramework
TaskCalls
3
Faites glisser le nœud vers le nouveau
graphe de dépendance.
-
4
Cliquez avec le bouton de la souris sur
SR_MainMachine dans le graphe de
dépendance, puis sélectionnez Ajouter
tous mes > Ajouter tous mes actions
dans le menu contextuel.
Le nœud SR_MainMachine et les actions
associées s'affichent de manière
désordonnée.
5
Ouvrez la liste Disposition, sélectionnez
LinLog, puis cliquez sur Appliquer.
Le nœud SR_MainMachine et les actions
associées s'affichent sous forme radiale.
>
NOTE: Il s'agit d'un exemple. Vous pouvez faire glisser tous les objets de
votre application vers le graphe de dépendance.
EIO0000004079.02
51
Machine Code Analysis
Annexes
Contenu de cette partie
Requêtes de dépendance (filtre)......................................................................54
Requêtes de dépendance (sélection)...............................................................56
Métriques ......................................................................................................60
Conventions ..................................................................................................83
EIO0000004079.02
53
Machine Code Analysis
Requêtes de dépendance (filtre)
Requêtes de dépendance (filtre)
Contenu de ce chapitre
Requêtes de dépendance (filtre).....................................................................54
Requêtes de dépendance (filtre)
Requêtes de dépendance (filtre)
Les requêtes suivantes sont disponibles par défaut (avec l'installation
d'EcoStruxure Machine Expert).
Nom
Description
Call Graph
Description : cette chaîne de requête permet d'obtenir les fronts d'appel et
les nœuds connectés (source ou cible du front). Le résultat est appliqué au
contenu actuel d'une vue de dépendance afin d'afficher ou de masquer les
nœuds et les fronts.
Cas d'utilisation : une fois la vue de dépendance dont le contenu
correspond à la requête Call Graph générée, ce filtre permet d'afficher
uniquement les nœuds appelés et les fronts d'appel.
Extend Graph
Description : cette chaîne de requête permet d'obtenir les fronts
d'extension et les nœuds connectés (source ou cible du front). Le résultat
est appliqué au contenu de la vue de dépendance afin d'afficher ou de
masquer les nœuds et les fronts.
Cas d'utilisation : une fois la vue de dépendance dont le contenu
correspond à la requête Extend Graph générée, ce filtre permet d'afficher
uniquement les nœuds étendus ou qui étendent d'autres nœuds ainsi que
les fronts d'extension.
GVL Graph
Description : cette chaîne de requête permet d'obtenir les nœuds de GVL.
Le résultat est appliqué au contenu de la vue de dépendance afin
d'afficher ou de masquer les nœuds.
Cas d'utilisation : une fois la vue de dépendance dont le contenu
correspond à la requête GVL Graph générée, ce filtre permet d'afficher
uniquement les nœuds de GVL.
GVL+Variable Graph
Description : cette chaîne de requête permet d'obtenir les nœuds de GVL
et de variable et les fronts qui connectent ces nœuds (source ou cible du
front). Le résultat est appliqué au contenu de la vue de dépendance afin
d'afficher ou de masquer les nœuds et les fronts.
Cas d'utilisation : une fois la vue de dépendance dont le contenu
correspond à la requête GVL+Variable Graph générée, ce filtre permet
d'afficher uniquement les nœuds de GVL et de variable ainsi que les fronts
qui les connectent.
Implement Graph
Description : cette chaîne de requête permet d'obtenir les fronts
d'implémentation et les nœuds connectés (source ou cible du front). Le
résultat est appliqué au contenu de la vue de dépendance afin d'afficher
ou de masquer les nœuds et les fronts.
Cas d'utilisation : une fois la vue de dépendance dont le contenu
correspond à la requête Implement Graph générée, ce filtre permet
d'afficher uniquement les nœuds implémentés ou qui implémentent
d'autres nœuds ainsi que les fronts d'extension.
Implement+Extend
Graph
Description : cette chaîne de requête permet d'obtenir les fronts
d'extension et d'implémentation et les nœuds connectés (source ou cible
du front). Le résultat est appliqué au contenu de la vue de dépendance
afin d'afficher ou de masquer les nœuds et les fronts.
Cas d'utilisation : une fois la vue de dépendance dont le contenu
correspond à la requête Implement+Extend Graph générée, ce filtre
permet d'afficher uniquement les nœuds étendus/implémentés ou qui
étendent/implémentent d'autres nœuds ainsi que les fronts d'extension et
d'implémentation.
Library Stack
54
Description : cette chaîne de requête permet d'obtenir les nœuds de
bibliothèque. Le résultat est appliqué au contenu de la vue de dépendance
afin d'afficher ou de masquer les nœuds et les fronts.
EIO0000004079.02
Requêtes de dépendance (filtre)
Machine Code Analysis
Nom
Description
Cas d'utilisation : une fois la vue de dépendance dont le contenu
correspond à la requête Library Stack générée, ce filtre permet d'afficher
uniquement les nœuds de bibliothèque et les fronts « uses » qui les
connectent.
Node Graph
Description : cette chaîne de requête permet d'obtenir les nœuds (tous
types confondus). Le résultat est appliqué au contenu de la vue de
dépendance afin d'afficher ou de masquer les nœuds et les fronts.
Cas d'utilisation : une fois la vue de dépendance dont le contenu
correspond à la requête Node Graph générée, ce filtre permet d'afficher
tous les types de nœuds et les fronts qui les connectent.
POU Graph
Description : cette chaîne de requête permet d'obtenir les nœuds de POU.
Le résultat est appliqué au contenu de la vue de dépendance afin
d'afficher ou de masquer les nœuds et les fronts.
Cas d'utilisation : une fois la vue de dépendance dont le contenu
correspond à la requête POU Graph générée, ce filtre permet d'afficher
uniquement les nœuds de POU et les fronts qui les connectent.
POU+Variable Graph
Description : cette chaîne de requête permet d'obtenir les nœuds de POU
et de variable et les fronts qui connectent ces nœuds (source ou cible du
front). Le résultat est appliqué au contenu de la vue de dépendance afin
d'afficher ou de masquer les nœuds et les fronts.
Cas d'utilisation : une fois la vue de dépendance dont le contenu
correspond à la requête POU+Variable Graph générée, ce filtre permet
d'afficher uniquement les nœuds de POU et de variable ainsi que les
fronts qui les connectent.
Read Graph
Description : cette chaîne de requête permet d'obtenir les nœuds de POU
et de variable et les fronts de lecture qui connectent ces nœuds (source ou
cible du front). Le résultat est appliqué au contenu de la vue de
dépendance afin d'afficher ou de masquer les nœuds et les fronts.
Cas d'utilisation : une fois la vue de dépendance dont le contenu
correspond à la requête Read Graph générée, ce filtre permet d'afficher
uniquement les nœuds de POU et de variable connectés via des fronts de
lecture.
Read+Write Graph
Description : cette chaîne de requête permet d'obtenir les nœuds de POU
et de variable et les fronts d'écriture ou de lecture qui connectent ces
nœuds (source ou cible du front). Le résultat est appliqué au contenu de la
vue de dépendance afin d'afficher ou de masquer les nœuds et les fronts.
Cas d'utilisation : une fois la vue de dépendance dont le contenu
correspond à la requête Read+Write Graph générée, ce filtre permet
d'afficher uniquement les nœuds de POU et de variable connectés via des
fronts de lecture ou d'écriture.
Write Graph
Description : cette chaîne de requête permet d'obtenir les nœuds de POU
et de variable et les fronts d'écriture qui connectent ces nœuds (source ou
cible du front). Le résultat est appliqué au contenu de la vue de
dépendance afin d'afficher ou de masquer les nœuds et les fronts.
Cas d'utilisation : une fois la vue de dépendance dont le contenu
correspond à la requête Write Graph générée, ce filtre permet d'afficher
uniquement les nœuds de POU et de variable connectés via des fronts
d'écriture.
Device Graph
Description : cette chaîne de requête permet d'obtenir les équipements et
les fronts qui connectent ces nœuds.
Cas d'utilisation : une fois la vue de dépendance dont le contenu
correspond à la requête, page 56 Sélectionner et ajouter Device Graph
générée, ce filtre permet d'afficher uniquement les équipements.
Test Element Graph
Description : cette chaîne de requête permet d'obtenir les éléments de test
(TestCase, TestResource, TestSet, etc.) et les fronts qui connectent ces
nœuds.
Cas d'utilisation : une fois la vue de dépendance dont le contenu
correspond à la requête, page 56 Sélectionner et ajouter Test Element
Graph générée, ce filtre permet d'afficher uniquement les éléments de
test.
EIO0000004079.02
55
Machine Code Analysis
Requêtes de dépendance (sélection)
Requêtes de dépendance (sélection)
Contenu de ce chapitre
Requêtes de dépendance (sélection)..............................................................56
Requêtes de dépendance (sélection)
Requêtes de dépendance (sélection)
Les requêtes suivantes sont disponibles par défaut (avec l'installation
d'EcoStruxure Machine Expert).
Groupe : Misc
Nom
Description
Call Graph
Description : cette chaîne de requête génère une vue de dépendance avec les POU appelants
ou appelés par un autre POU appartenant à la portée sélectionnée (définie sous l'application,
par exemple).
Résultats : en supposant qu'une seule tâche soit définie et qu'un seul programme (PRG) soit
exécuté, le graphe obtenu est une arborescence de POU connectés via des fronts d'appel.
Lorsque plusieurs tâches sont définies ou plusieurs programmes (PRG) sont exécutés,
l'implémentation détermine si un POU commun est appelé ou non par les deux programmes.
Vous obtenez alors plusieurs diagrammes d'appel dans une même vue de dépendance (sous
forme de graphe).
Cas d'utilisation : la vue de dépendance permet d'effectuer une analyse graphique du
diagramme d'appel, de savoir quels POU sont utilisés par tel ou tel POU, et lesquels sont utilisés
plusieurs fois.
Lorsqu'un POU est appelé plusieurs fois, le problème est automatiquement résolu au niveau du
POU dans les deux diagrammes d'appel.
Exemple de code source :
fbMyFunctionBlock.TestMethod();
Extend (FunctionBlock)
Description : cette chaîne de requête génère une vue de dépendance avec les blocs fonction
(FB) appartenant à la portée sélectionnée (définie sous l'application, par exemple) qui étendent
un autre bloc fonction.
Prenons l'exemple d'un bloc fonction de base appelé FB_DriveBase. Ce bloc fonction peut être
étendu par les blocs FB_LXM52 et FB_LXM62.
Résultats : vous obtenez un graphe des blocs fonction connectés via des fronts d'extension.
À partir d'un bloc fonction dans un sous-nœud (c'est-à-dire un bloc fonction non étendu par un
autre bloc tel que FB_LMX62), vous obtenez la chaîne de blocs vers son bloc de base.
Pour les blocs fonction d'un projet, vous voyez les blocs fonction frères reposant sur le même
bloc de base.
Cas d'utilisation : la vue de dépendance permet de visualiser la chaîne étendue de blocs
fonction. Vous pouvez savoir si des blocs frères étendent le même bloc de base avec des
fonctionnalités identiques et pourraient être remplacés par un autre. Par exemple, vous pouvez
utiliser les blocs FB_LXM62 et FB_LXM52 comme argument d'entrée de méthode basé sur FB_
DriveBase. Cette méthode peut prendre en charge les deux types de variateurs.
Exemple de code source :
FUNCTION_BLOCK FB_MyTest EXTENDS FB_MyTestBase
Extend (Interface)
Description : cette chaîne de requête génère une vue de dépendance avec les interfaces
appartenant à la portée sélectionnée (définie sous l'application, par exemple) qui étendent une
autre interface.
Prenons l'exemple d'une interface de base appelée IF_DriveBase. Cette interface peut être
étendue par les blocs IF_LXM52 et IF_LXM62.
Résultats : vous obtenez un graphe des interfaces connectées via des fronts d'extension.
À partir d'une interface dans un sous-nœud (c'est-à-dire une interface non étendue par une
autre interface telle que IF_LMX62), vous obtenez la chaîne d'interfaces vers son interface de
base.
Pour les interfaces d'un projet, vous voyez les interfaces sœurs reposant sur la même interface
de base.
56
EIO0000004079.02
Requêtes de dépendance (sélection)
Nom
Machine Code Analysis
Description
Cas d'utilisation : la vue de dépendance permet de visualiser la chaîne étendue d'interfaces.
Vous pouvez savoir si des interfaces sœurs étendent la même interface de base avec des
fonctionnalités identiques et pourraient être remplacées par une autre. Par exemple, vous
pouvez utiliser les interfaces IF_LXM62 ou IF_LXM52 comme argument d'entrée de méthode
basé sur IF_DriveBase. Cette méthode peut prendre en charge les deux types de variateurs.
Exemple de code source :
INTERFACE IF_MyTest EXTENDS IF_MyTestBase
Extend Graph
Description : cette chaîne de requête génère une vue de dépendance avec les interfaces et les
blocs fonction (FB) appartenant à la portée sélectionnée (définie sous l'application, par
exemple) qui étendent une autre interface.
Prenons l'exemple d'une interface de base appelée IF_DriveBase. Cette interface peut être
étendue par les blocs IF_LXM52 et IF_LXM62 (également valable pour les blocs fonction).
Résultats : vous obtenez un graphe des interfaces et blocs fonction connectés via des fronts
d'extension.
À partir d'une interface/d'un bloc fonction dans un sous-nœud (c'est-à-dire une interface/un bloc
non étendu(e) par une autre interface/un autre bloc tel(le) que IF_LMX62), vous obtenez la
chaîne d'interfaces/de blocs fonction vers son interface/bloc de base.
Pour les interfaces/blocs fonction d'un projet, vous voyez les interfaces sœurs/blocs fonction
frères reposant sur la même interface/le même bloc de base.
Cas d'utilisation : la vue de dépendance permet de visualiser la chaîne étendue d'interfaces et
de blocs fonction. Vous pouvez savoir si des interfaces sœurs/blocs fonction frères étendent la
même interface/le même bloc de base avec des fonctionnalités identiques et pourraient être
remplacé(e)s par un(e) autre. Par exemple, vous pouvez utiliser les interfaces IF_LXM62 ou IF_
LXM52 comme argument d'entrée de méthode basé sur IF_DriveBase. Cette méthode peut
prendre en charge les deux types de variateurs.
Exemple de code source :
FUNCTION_BLOCK FB_MyTest EXTENDS FB_MyTestBase
ou
INTERFACE IF_MyTest EXTENDS IF_MyTestBase
GVL Graph
Description : cette chaîne de requête génère une vue de dépendance avec les listes de
variables globales (GVL) définies appartenant à la portée sélectionnée (définie sous
l'application, par exemple).
Résultats : vous obtenez un graphe des nœuds de GVL, sans les fronts qui les connectent.
Cas d'utilisation : cette vue de dépendance permet d'explorer les listes de variables globales.
Vous pouvez ainsi ajouter les variables connectées à la liste qui vous intéresse, par exemple.
Exemple de code source :
VAR_GLOBAL
G_iGVLTestVar: INT;
END_VAR
GVL+Variable Graph
Description : cette chaîne de requête génère une vue de dépendance avec les listes de
variables globales (GVL) définies appartenant à la portée sélectionnée (définie sous
l'application, par exemple) et les variables définies dans ces listes.
Résultats : vous obtenez un graphe des nœuds de GVL et de variable, avec leurs dépendances.
Lorsque plusieurs listes de variables globales sont définies dans une application, vous voyez
des groupes de nœuds (une liste et ses variables). En général, les groupes ne sont pas
connectés les uns aux autres.
Cas d'utilisation : cette vue de dépendance permet d'explorer les listes de variables globales et
les variables du projet. Vous pouvez ajouter des nœuds d'écriture et de lecture, par exemple,
pour voir si une variable est utilisée par plusieurs extraits de code ou par un seul nœud à
déclarer en local (dans un programme, par exemple).
Exemple de code source :
VAR_GLOBAL
G_iGVLTestVar: INT;
END_VAR
Implement Graph
Description : cette chaîne de requête génère une vue de dépendance avec les blocs fonction
(FB) implémentant des interfaces appartenant à la portée sélectionnée (définie sous
l'application, par exemple).
Résultats : vous obtenez un graphe des blocs fonction et interfaces connectés via des fronts
d'implémentation.
Pour les blocs fonction d'un projet, vous pouvez également identifier l'autre bloc fonction
implémentant les interfaces liées.
EIO0000004079.02
57
Machine Code Analysis
Nom
Requêtes de dépendance (sélection)
Description
Cas d'utilisation : la vue de dépendance permet de visualiser les dépendances d'implémentation
concernant les blocs fonction. Vous pouvez par exemple visualiser les implémentations
d'interface manquantes lorsque plusieurs types de blocs fonction doivent respecter la même
spécification qui sera utilisée par une méthode.
Exemple de code source :
FUNCTION_BLOCK FB_MyTest IMPLEMENTS IF_MyTest, IF_MyTest2
Implement+Extend Graph
Description : cette chaîne de requête génère une vue de dépendance avec les blocs fonction
(FB) et les interfaces appartenant à la portée sélectionnée (définie sous l'application, par
exemple), ainsi que leurs connexions.
Résultats : vous obtenez un graphe des blocs fonction et interfaces connectés via des fronts
d'implémentation ou d'extension.
Cas d'utilisation : cette vue de dépendance permet de visualiser en même temps les
dépendances d'implémentation et d'extension.
Exemple de code source :
FUNCTION_BLOCK FB_MyTest EXTENDS FB_MyTestBase IMPLEMENTS IF_MyTest,
IF_MyTest2
Library Stack
Description : cette chaîne de requête génère une vue de dépendance avec les bibliothèques
utilisées dans le projet.
Résultats : vous obtenez la pile de bibliothèques sur laquelle repose votre application. Vous
voyez les bibliothèques référencées de manière directe et indirecte.
Cas d'utilisation : la vue de dépendance permet de visualiser toute la pile de bibliothèques de
façon graphique. Vous voyez les couches de bibliothèque.
Exemple : Application > Bibliothèques technologiques
Bibliothèques système (API de micrologiciel)
Node Graph
> Bibliothèque PacDrive >
Description : cette chaîne de requête génère une vue de dépendance complète des nœuds
appartenant à la portée sélectionnée (définie sous l'application, par exemple) et de leurs
connexions.
Résultats : le graphe obtenu contient tous les nœuds (blocs fonction, programmes, fonctions,
variables, bibliothèques, DUT, etc.) et les différents types de fronts qui les connectent.
Cas d'utilisation : cette vue de dépendance permet de visualiser le projet complet. N'oubliez pas
qu'elle contient de nombreux types de nœuds et de fronts différents et qu'il est impossible
d'obtenir une vue spécifique du code (comparé au diagramme d'appel, par exemple).
POU Graph
Description : cette chaîne de requête génère une vue de dépendance avec les blocs fonction/
fonctions (POU) définis appartenant à la portée sélectionnée (définie sous l'application, par
exemple).
Résultats : vous obtenez un graphe des nœuds de POU. Lorsque les POU sont liés, via un front
d'appel par exemple, ce front s'affiche également.
Cas d'utilisation : cette vue de dépendance permet d'explorer les POU. Vous pouvez ainsi
ajouter les variables connectées au POU qui vous intéresse, par exemple.
POU+Variable Graph
Description : cette chaîne de requête génère une vue de dépendance avec les programmes/
blocs fonction/fonctions (POU) définis appartenant à la portée sélectionnée (définie sous
l'application, par exemple) et les variables définies dans ces POU.
Résultats : vous obtenez un graphe des nœuds de programme et de variable, avec leurs
dépendances.
Cas d'utilisation : cette vue de dépendance permet d'explorer les POU et les variables du projet.
Vous pouvez ajouter des nœuds d'écriture et de lecture, par exemple, pour voir si une variable
est utilisée par plusieurs extraits de code ou par un seul nœud à déclarer en local (dans un
POU, par exemple).
Exemple de code source :
PROGRAM SR_MyTest
VAR
iSRTestVar: INT;
END_VAR
Read Graph
Description : cette chaîne de requête génère une vue de dépendance avec les opérations de
lecture appartenant à la portée sélectionnée (définie sous l'application, par exemple) qui
concernent les variables.
Résultats : vous obtenez un graphe des POU (programmes, fonctions, blocs fonction, etc.) et
des variables liées via un front de lecture.
Cas d'utilisation : cette vue de dépendance permet d'explorer les opérations de lecture
concernant les variables et de déterminer si ces variables sont lues une ou plusieurs fois dans le
projet.
58
EIO0000004079.02
Requêtes de dépendance (sélection)
Nom
Machine Code Analysis
Description
Exemple de code source :
dummy0 := iSRTestVar;
Read+Write Graph
Description : cette chaîne de requête génère une vue de dépendance avec les opérations de
lecture et d'écriture appartenant à la portée sélectionnée (définie sous l'application, par
exemple) qui concernent les variables.
Résultats : vous obtenez un graphe des POU (programmes, fonctions, blocs fonction, etc.) et
des variables liées via un front de lecture ou d'écriture.
Cas d'utilisation : cette vue de dépendance permet d'explorer les opérations de lecture et
d'écriture concernant les variables et de déterminer si ces variables sont lues une ou plusieurs
fois dans le projet, sans jamais être écrites.
Exemple de code source :
dummy0 := iSRTestVar;
iSRTestVar := dummy0;
Write Graph
Description : cette chaîne de requête génère une vue de dépendance avec les opérations
d'écriture appartenant à la portée sélectionnée (définie sous l'application, par exemple) qui
concernent les variables.
Résultats : vous obtenez un graphe des POU (programmes, fonctions, blocs fonction, etc.) et
des variables liées via un front d'écriture.
Cas d'utilisation : cette vue de dépendance permet d'explorer les opérations d'écriture
concernant les variables et de déterminer si ces variables sont écrites une ou plusieurs fois dans
le projet.
Exemple de code source :
iSRTestVar := dummy0;
Device Graph
Description : cette chaîne de requête génère une vue de dépendance de l'arborescence
d'équipements.
Résultats : vous obtenez une arborescence d'équipements avec les instances d'équipement et
leurs dépendances de sous-nœud.
Cas d'utilisation : cette vue de dépendance permet de visualiser l'arborescence d'équipements
et d'explorer les dépendances avec les variables qui représentent ces équipements dans
l'application.
Test Element Graph
Description : cette chaîne de requête génère une vue de dépendance des éléments de test
(TestCases, TestResources, TestSets, etc.).
Résultats : vous pouvez visualiser les éléments de test et leurs dépendances.
Cas d'utilisation : cette vue de dépendance permet d'identifier l'élément TestCase qui réutilise
des éléments TestResources ou TestSets, et d'accéder aux différents éléments testés
(fonctions, méthodes, blocs fonction, etc.).
EIO0000004079.02
59
Machine Code Analysis
Métriques
Métriques
Contenu de ce chapitre
Métrique : taille de l'application (code).............................................................60
Métrique : taille de l'application (code+données) ..............................................61
Métrique : taille de l'application (données) .......................................................61
Métrique : Call In ..........................................................................................62
Métrique : Call Out.........................................................................................62
Métrique : taux de variables commentées (toutes) ...........................................62
Métrique : taux de variables commentées (entrée+sortie+globale) ....................63
Métrique : Cyclomatic Complexity ...................................................................63
Métrique : Extended By..................................................................................65
Métrique : Extends ........................................................................................65
Métrique : Fan In ...........................................................................................66
Métrique : Fan Out.........................................................................................66
Métrique : Halstead Complexity ......................................................................67
Métrique : Implemented By ............................................................................70
Métrique : Implements ...................................................................................71
Métrique : Lines Of Code (LOC) .....................................................................72
Métrique : Memory Size (Data) .......................................................................72
Métrique : Number Of Actions ........................................................................73
Métrique : Number Of GVL Usages.................................................................74
Métrique : nombre de lignes de commentaire en en-tête...................................74
Métrique : Number Of Instances .....................................................................75
Métrique : Number Of Library References .......................................................75
Métrique : Number Of Messages ....................................................................76
Métrique : Number Of Methods.......................................................................76
Métrique : nombre de commentaires multilignes ..............................................77
Métrique : Number Of Properties ....................................................................77
Métrique : Number Of Reads..........................................................................78
Métrique : Number Of Tasks ...........................................................................78
Métrique : Number Of Transitions ...................................................................79
Métrique : Number Of Variables......................................................................79
Métrique : Number Of Writes ..........................................................................80
Métrique : Number Of FBD Networks ..............................................................80
Métrique : taux de commentaires dans le code source .....................................80
Métrique : Stack Size.....................................................................................81
Métrique : taille de l'application (code)
User Description
Les applications écrites en langage de programmation IEC-61131-3 se
composent de blocs fonction, de programmes, de fonctions, de listes de variables
globales, etc.
Lorsqu'elles sont connectées à un contrôleur, le code source est compilé et un
exécutable est envoyé au contrôleur.
Cet exécutable consiste en sections de code et de données lorsqu'il est chargé
dans la mémoire du contrôleur.
La taille du code de l'application est la quantité de mémoire nécessaire sur le
contrôleur pour gérer le code d'application.
NOTE: Cette métrique peut être calculée uniquement lorsque vous activez
l'option Prendre en compte le code et la taille des données dans l'onglet
Configuration de l'analyseur de code, page 28.
Metric Calculation
La taille du code d'application est calculée sur la base de la taille du code machine
généré pour chaque POU (programme, bloc fonction, fonction).
60
EIO0000004079.02
Métriques
Machine Code Analysis
Métrique : taille de l'application (code+données)
User Description
Les applications écrites en langage de programmation IEC-61131-3 se
composent de blocs fonction, de programmes, de fonctions, de listes de variables
globales, etc.
Lorsqu'elles sont connectées à un contrôleur, le code source est compilé (avec
génération de code) et un exécutable est envoyé au contrôleur.
Cet exécutable consiste en sections de code et de données lorsqu'il est chargé
dans la mémoire du contrôleur.
La taille du code et des données de l'application est la quantité minimum de
mémoire nécessaire sur le contrôleur pour exécuter l'application.
NOTE: Cette métrique peut être calculée uniquement lorsque vous activez
l'option Prendre en compte le code et la taille des données dans l'onglet
Configuration de l'analyseur de code, page 28.
Metric Calculation
La taille du code d'application est calculée sur la base de la taille du code machine
généré pour chaque POU (programme, bloc fonction, fonction).
La taille des données de l'application est calculée sur la base de la taille de toutes
les variables de l'application.
NOTE: La somme de la taille du code d'application et de la taille des données
d'application (voir la métrique dédiée) n'est pas exactement égale à la taille
d'application code + données (cette métrique) en raison de l'alignement ou de
la taille de page de code du matériel contrôleur sous-jacent.
Métrique : taille de l'application (données)
User Description
Les applications écrites en langage de programmation IEC-61131-3 se
composent de blocs fonction, de programmes, de fonctions, de listes de variables
globales, etc.
Lorsqu'elles sont connectées à un contrôleur, le code source est compilé (avec
génération de code) et un exécutable est envoyé au contrôleur.
Cet exécutable consiste en sections de code et de données lorsqu'il est chargé
dans la mémoire du contrôleur.
La taille des données d'application est la quantité de mémoire nécessaire sur le
contrôleur pour gérer les données nécessaires à l'exécution du code d'application.
NOTE: Cette métrique peut être calculée uniquement lorsque vous activez
l'option Prendre en compte le code et la taille des données dans l'onglet
Configuration de l'analyseur de code, page 28.
Metric Calculation
La taille des données de l'application est calculée sur la base de la taille de toutes
les variables de l'application.
EIO0000004079.02
61
Machine Code Analysis
Métriques
Métrique : Call In
User Description
La métrique Call In est utilisée pour obtenir des informations sur l'appelant d'une
méthode, d'une fonction, d'un bloc fonction, etc.
Metric Calculation
Chaque appel à une implémentation est pris en compte, mais si le même objet
(méthode, fonction...) est appelé deux fois dans la même implémentation, il est
compté une seule fois.
Exemple
Exemple de calcul de la métrique Call In pour du code IEC-61131-3 :
METH();
// Some other implementation
METH();
Résultat de la métrique Call In (pour la méthode METH)
Call In = 1
Métrique : Call Out
User Description
La métrique Call Out est utilisée pour obtenir des informations sur les autres
objets (méthode, fonction, bloc fonction...) appelés par l'implémentation.
Metric Calculation
Chaque appel à une implémentation est pris en compte, mais si le même objet
(méthode, fonction...) est appelé deux fois dans la même implémentation, il est
compté une seule fois.
Exemple
Exemple de calcul de la métrique Call Out pour du code IEC-61131-3 :
METH();
// Some other implementation
METH();
Résultat de la métrique Call Out (pour la méthode METH)
Call Out = 1
Métrique : taux de variables commentées (toutes)
User Description
Cette métrique calcule taux (unité : %) entre variables commentées et non
commentées dans un objet IEC.
62
EIO0000004079.02
Métriques
Machine Code Analysis
Metric Calculation
Pour chaque déclaration de variable dans les objets IEC (fonction (FUN), bloc
fonction (FB), type d'unité de données (DUT), liste de variables globales (GVL),
etc.), l'analyse vérifie si elle est commentée ou non.
Cette métrique fournit le rapport entre les deux valeurs.
Exemple
Exemple de calcul du taux de variables commentées pour du code IEC-61131-3 :
Declaration:
1: PROGRAM SR_Main
2: VAR
3:
xCheck1: BOOL;//flag to identify
4:
uiMyVariable2: UINT;
5:
xFlag: BOOL;
6: END_VAR
Taux de variables commentées : 33,33 %
Métrique : taux de variables commentées (entrée+sortie+globale)
User Description
Cette métrique calcule le rapport (unité : %) entre variables commentées et non
commentées définies dans VAR_GLOBAL, VAR_INPUT, VAR_OUTPUT ou VAR_
IN_OUT.
Metric Calculation
Pour chaque déclaration de variable dans les objets IEC (fonction (FUN), bloc
fonction (FB), type d'unité de données (DUT), liste de variables globales (GVL),
etc.), l'analyse vérifie si elle est commentée ou non.
Cette métrique fournit le rapport entre les deux valeurs.
Exemple
Exemple de calcul du taux de variables commentées (entrée+sortie+globale) pour
du code IEC-61131-3 :
Declaration:
1: PROGRAM SR_Main
2: VAR_IN
3:
i_xCheck1: BOOL;//flag to identify
3:
i_uiMyVariable2: UINT;
4: END_VAR
2: VAR
3:
xFlag: BOOL;
4: END_VAR
Taux de variables commentées (entrée+sortie+globale) : 50 %
Métrique : Cyclomatic Complexity
User Description
La métrique Cyclomatic Complexity est utilisée pour mesurer la complexité d'un
programme en comptabilisant le nombre de chemins linéairement indépendants
dans le code source.
EIO0000004079.02
63
Machine Code Analysis
Métriques
Metric Calculation
La métrique Cyclomatic Complexity est calculée à l'aide du graphique de contrôle
de déroulement du programme. Cette mesure de complexité dépend des points
de condition et de décision inclus dans ce graphique.
Par exemple :
•
Aucun point de condition ou de décision : complexité = 1 (un seul chemin à
travers le code).
•
Une instruction IF : complexité = 2 (deux chemins à travers le code).
•
Une instruction IF avec deux conditions : complexité = 3 (trois chemins à
travers le code).
•
…
En fonction de l'outil d'analyse utilisé, il existe plusieurs interprétations/
implémentations de la métrique Cyclomatic Complexity. Certains outils ne
tiennent pas compte des expressions AND/OR/... dans les instructions IF,
REPEAT, WHILE, etc. La métrique McCabe Cyclomatic Complexity est toujours
incrémentée de 1. D'autres outils prennent également en compte les expressions
du flux de code (hors instruction IF, REPEAT, etc.) mais utilisées ultérieurement
dans une instruction IF ou REPEAT, ce qui produit un résultat Cyclomatic
Complexity plus élevé. L'implémentation de la métrique Cyclomatic Complexity
pour le code IEC-61131-3 dans EcoStruxure Machine Expert tient compte des
expressions contenant AND/OR/..., mais pas des expressions précalculées dans
le flux du code ou indiquées à un appel de méthode.
Exemple
Exemple de calcul de la métrique Cyclomatic Complexity pour du code IEC61131-3 :
// MCC +1 (Initial Value)
// MCC +0 (Pre calculation of condition not considered)
a := b OR c;
// MCC +0 (Method call with condition not considered in
calling implementation)
METH4(a);
IF a AND b OR c XOR d AND NOT e THEN
// MCC +5 (IF with 5 conditions)
CASE i OF
1..4:
// MCC +1 (CASE range is considered as one
condition)
FOR i := 1 TO 10 DO
// MCC +1
METH1();
END_FOR
10, 11, 12, 13:
// MCC +1 (multiple CASE labels considered as one
condition)
REPEAT
// MCC +1 (one condition in REPEAT)
WHILE (a = TRUE AND b = FALSE) DO
// MCC +2 (two conditions in WHILE)
METH2();
END_WHILE
64
EIO0000004079.02
Métriques
Machine Code Analysis
UNTIL (TRUE) END_REPEAT
ELSE
// MCC +0 (Default path through CASE statement)
METH3();
END_CASE
END_IF
Résultat de la métrique Cyclomatic Complexity
Cyclomatic Complexity (MCC) = 12
Métrique : Extended By
User Description
La métrique Extended By est utilisée pour obtenir des informations sur la
fréquence d'extension d'un bloc fonction ou d'une interface par un autre bloc
fonction ou une autre interface.
Metric Calculation
Un bloc fonction peut étendre exactement un bloc fonction et implémenter
plusieurs interfaces. Une interface peut étendre plusieurs interfaces mais ne peut
pas implémenter d'autres interfaces.
Un bloc fonction ou une interface peut être étendu(e) par zéro ou plusieurs
interfaces. Le nombre d'interfaces étendues directes est compté.
Exemple
Exemple de calcul de Extended By pour du code IEC-61131-3 :
FB_Test extends FB_Base implements IF_Test1, IF_Test2
FB_Base implements IF_Test4
IF_Test2 extends IF_Test3, IF_Test5
Résultats du calcul de Implemented By
Extended By (FB_Base) = 1
Extended By (IF_Test3) = 1
Extended By (IF_Test5) = 1
Métrique : Extends
User Description
La métrique Extends est utilisée pour obtenir des informations sur le nombre
d'interfaces étendues par un bloc fonction ou une interface.
Metric Calculation
Un bloc fonction peut étendre exactement un bloc fonction et implémenter
plusieurs interfaces. Une interface peut étendre plusieurs interfaces mais ne peut
pas implémenter d'autres interfaces.
Un bloc fonction ou une interface peut étendre zéro ou plusieurs interfaces. Le
nombre d'interfaces étendues directes est compté.
Exemple
Exemple de calcul de Extends pour du code IEC-61131-3 :
FB_Test extends FB_Base implements IF_Test1, IF_Test2
EIO0000004079.02
65
Machine Code Analysis
Métriques
FB_Base implements IF_Test4
IF_Test2 extends IF_Test3, IF_Test5
Résultats du calcul de Implemented By
Extends (FB_Test) = 1
Extends (IF_Test2) = 2
Métrique : Fan In
User Description
La métrique Fan In est utilisée pour obtenir des informations sur le nombre de
dépendances entrantes (lectures, écritures, appels, etc.) vers un noeud du
modèle de données d'analyse (modèle de dépendance). Une dépendance
entrante signifie, par exemple, qu'un noeud est appelé et qu'un autre noeud en
dépend.
Metric Calculation
Chaque dépendance entrante est prise en compte pour un noeud donné. Un
noeud peut être un bloc fonction, un programme, une fonction, une variable, une
bibliothèque, une propriété, une méthode, une tâche, etc.
Exemple
Exemple de dépendance (liste de dépendances) :
FunctionBlockA defines MethodA
FunctionBlockA defines MethodB
FunctionBlockA defines VariableC
FunctionBlockA calls MethodA
MethodA calls MethodB
MethodB reads VariableC
Résultats de la métrique Fan In
Fan In (FunctionBlockA) = 0
Fan In (MethodA) = 2
Fan In (MethodB) = 2
Fan In (VariableC) = 2
Métrique : Fan Out
User Description
La métrique Fan Out est utilisée pour obtenir des informations sur le nombre de
dépendances sortantes (lectures, écritures, appels, etc.) présentées par un noeud
du modèle de données d'analyse (modèle de dépendance). Une dépendance
sortante signifie, par exemple, qu'un noeud est appelé et qu'un autre noeud en
dépend.
Metric Calculation
Chaque dépendance sortante est prise en compte pour un noeud donné. Un
noeud peut être un bloc fonction, un programme, une fonction, une variable, une
bibliothèque, une propriété, une méthode, une tâche, etc.
Exemple
Exemple de dépendance (liste de dépendances) :
FunctionBlockA defines MethodA
FunctionBlockA defines MethodB
FunctionBlockA defines VariableC
66
EIO0000004079.02
Métriques
Machine Code Analysis
FunctionBlockA calls MethodA
MethodA calls MethodB
MethodB reads VariableC
Résultats de la métrique Fan Out
Fan Out (FunctionBlockA) = 4
Fan Out (MethodA) = 1
Fan Out (MethodB) = 1
Fan Out (VariableC) = 0
Métrique : Halstead Complexity
User Description
La métrique Halstead Complexity est utilisée pour mesurer la complexité d'un
programme logiciel sans l'exécuter.
Cette méthode de test statique permet d'identifier et d'évaluer des propriétés
mesurables du logiciel. Le code source est analysé et scindé en une suite de
jetons, lesquels sont ensuite classés et comptabilisés en tant qu'opérateurs ou
opérandes.
La métrique Halstead Complexity ne dépend d'aucune langage de programmation
et peut être appliquée au code source IEC-61131-3.
Les opérateurs et les opérandes sont classés et comptabilisés comme suit :
Paramètre
Description
n1
Nombre d'opérateurs distincts
n2
Nombre d'opérandes distinctes
N1
Nombre total d'opérateurs
N2
Nombre total d'opérandes
Plusieurs valeurs de métrique peuvent être calculées pour représenter différents
aspects de complexité :
•
Halstead Difficulty (D)
•
Halstead Length (N)
•
Halstead CalculatedLength (Nx)
•
Halstead Volume (V)
•
Halstead Effort (E)
•
Halstead Vocabulary (n)
Métrique Halstead Complexity des POU en langage ST (littéral structuré)
À l'origine, la métrique Halstead Complexity a été développée pour les langages
textuels (C, C++, Pascal…). Elle s'applique aux POU en langage ST.
NOTE: La métrique Halstead Difficulty est affichée par défaut.
Métrique Halstead Complexity des POU en langage FBD (diagramme à blocs fonction)
Le langage FBD est un langage d'implémentation graphique ; il n'est pas basé sur
du texte. Un POU se compose de plusieurs réseaux FBD. La métrique Halstead
Complexity doit être adaptée pour pouvoir s'appliquer aux langages graphiques.
Le concept de base est le même. On considère que les opérandes et les
opérateurs, ainsi que leur fréquence (par réseau FBD), sont présentés à
l'utilisateur (voir la section Exemple en langage FBD).
EIO0000004079.02
67
Machine Code Analysis
Métriques
Les valeurs Halstead Complexity calculées pour chaque réseau FBD sont
agrégées pour tous ces réseaux et associées au niveau du POU (programme,
bloc fonction, fonction, méthode ou propriété).
NOTE: Les valeurs Halstead calculées (pour chaque réseau FBD) sont FBD
Network Halstead Difficulty et FBD Network Halstead Length.
Les types d'agrégation suivants sont appliqués aux métriques Halstead (Halstead
Difficulty et Halstead Length) de chaque réseau FBD :
•
Moyenne
•
Minimum
•
Maximum
•
Somme
•
Cohérence
NOTE: Les valeurs agrégées les plus pertinentes sont FBD Halstead Difficulty
Network Max, FBD Halstead Difficulty Network Consistency, FBD Halstead
Length Network Max et FBD Halstead Length Network Consistency. Les
autres combinaisons (minimum, somme et moyenne) sont calculées et
associées au modèle, mais ne s'affichent pas par défaut.
Metric Calculation
Valeur
Formule
Halstead Difficulty (D)
D = (n1 / 2) * (N2 / n2)
Halstead Length (N)
N = N1 + N2
Halstead CalculatedLength (Nx)
Nx = n1 * log2(n1) + n2 * log2(n2)
Halstead Volume (V)
V = N * log2(n)
Halstead Effort (E)
E=V*D
Halstead Vocabulary (n)
n = n1 + n2
NOTE: Une expression contenue dans une instruction IF <expression> THEN
ne doit pas avoir de parenthèses. Ces expressions sont considérées comme
toujours disponibles dans le code source IEC-61131-3 .
Agrégation des valeurs de la métrique
Les résultats de la métrique, comme FBD Network Halstead Difficulty et FBD
Network Halstead Length, sont agrégés pour tous les réseaux FBD d'un POU.
Le paramètre values représente la liste des valeurs d'une métrique (par exemple,
FBD Network Halstead Length) pour tous les réseaux d'un POU.
La valeur de cohérence est le résultat du coefficient Gini. Ce coefficient est une
mesure de la dispersion statistique, qui sert à mesurer l'inégalité entre les valeurs
d'une distribution fréquente. Un coefficient Gini de 0 exprime une égalité parfaite
(les valeurs sont toutes identiques). Un coefficient Gini de 1 exprime une inégalité
maximale entre les valeurs.
Exemple en langage ST
Exemple de calcul de métrique Halstead pour du code IEC-61131-3 (seule la
partie implémentation est prise en compte pour le calcul) :
IF (xInit = FALSE) THEN
PerformInitialization();
xInit := TRUE;
ELSE
FOR i := 1 TO 5 DO
iAxisId := i + 7;
68
EIO0000004079.02
Métriques
Machine Code Analysis
sAxisName := Standard.CONCAT('MyAxis ', INT_TO_
STRING(iAxisId));
// Do some math calculations for each axis here
udiResult := CalculateStuff(sName := sAxisName, iID
:= iAxisId);
END_FOR
END_IF
Liste des opérateurs et de leurs fréquences :
Operator
Frequency
========
=========
(operators)
If
1
Then
1
LeftParenthesis
6
RightParenthesis
6
Equal
1
Semicolon
5
Assign
7
Else
1
For
1
EndFor
1
Do
1
Plus
1
Period
1
INT_TO_STRING
1
Colon
2
EndIf
1
(n1) 16
(N1) 37
Liste des opérandes et de leurs fréquences :
Operand
Frequency
=======
=========
(variables/methods/functions)
xInit
2
PerformInitialization
1
i
2
iAxisId
3
sAxisName
2
Standard
1
CONCAT
1
udiResult
1
CalculateStuff
1
sName
1
iID
1
(constants)
FALSE
TRUE
INT#1
INT#5
INT#7
'MyAxis '
(n2) 17
(N2)
1
1
1
1
1
1
22
Résultat de la métrique de difficulté Halstead
Halstead Difficulty (D = (16/2) * (22/17) = 10.3529411764706
Exemple en langage FBD
EIO0000004079.02
69
Machine Code Analysis
Métriques
Exemple de calcul de la métrique Halstead pour du code IEC-61131-3 en FBD
(seule la partie implémentation est prise en compte pour le calcul) :
Liste des opérateurs et de leurs fréquences :
Operator
Frequency
========
=========
(operators)
Assign
4
Set2
1
And
1
Negation2
2
Or
1
Eq
1
(n1)
6
(N1) 10
Liste des opérandes et de leurs fréquences :
Operand
Frequency
=======
=========
(variables/methods/functions/constants)
xResult
1
TON
1
fbTON
1
xEnable
1
T#1s
1
IN
1
PT
1
Q
1
ET
1
xTray1Empty
1
xTray2Empty
1
xInHomePosition
1
xBeltFull
1
xGroupReady
1
uiMasterStart
1
5
1
(n2) 16
(N2) 16
Résultat de la métrique FBD Network Halstead Difficulty
FBD Network Halstead Difficulty (D) = (6/2) * (16/16) = 3
Métrique FBD Network Halstead Length
FBD Network Halstead Length (D) = 10 + 16 = 26
Métrique : Implemented By
User Description
La métrique Implemented By est utilisée pour obtenir des informations sur la
fréquence d'implémentation d'une interface par un bloc fonction.
70
EIO0000004079.02
Métriques
Machine Code Analysis
Metric Calculation
Un bloc fonction peut étendre exactement un bloc fonction et implémenter
plusieurs interfaces. Une interface peut étendre plusieurs interfaces mais ne peut
pas implémenter d'autres interfaces.
Une interface peut être implémentée par plusieurs blocs fonction. Le nombre
d'interfaces implémentées directes est compté.
NOTE: Si un bloc fonction prolonge un autre bloc fonction ou qu'une interface
prolonge d'autres interfaces, les interfaces implémentées dérivées ne sont
pas prises en compte. Si une interface est implémentée dans le bloc fonction
de base et le bloc fonction dérivé, elle est comptée deux fois.
Exemple
Exemple de calcul de Implemented By pour du code IEC-61131-3 :
FB_Test extends FB_Base implements IF_Test1, IF_Test2
FB_Base implements IF_Test4, IF_Test1
IF_Test2 extends IF_Test3, IF_Test5
Résultats du calcul de Implemented By
Implemented By (IF_Test1) = 2
Implemented By (IF_Test2) = 1
Implemented By (IF_Test3) = 1
Implemented By (IF_Test4) = 1
Implemented By (IF_Test5) = 1
Métrique : Implements
User Description
La métrique Implements est utilisée pour obtenir des informations sur le nombre
d'interfaces implémentées par un bloc fonction.
Metric Calculation
Un bloc fonction peut étendre exactement un bloc fonction et implémenter
plusieurs interfaces. Une interface peut étendre plusieurs interfaces mais ne peut
pas implémenter d'autres interfaces.
Un bloc fonction peut implémenter zéro ou plusieurs interfaces. Le nombre
d'interfaces implémentées directes est compté.
NOTE: Si un bloc fonction prolonge un autre bloc fonction ou qu'une interface
prolonge d'autres interfaces, les interfaces implémentées dérivées ne sont
pas prises en compte.
Exemple
Exemple de calcul de Implements pour du code IEC-61131-3 :
FB_Test extends FB_Base implements IF_Test1, IF_Test2
FB_Base implements IF_Test4
IF_Test2 extends IF_Test3, IF_Test5
Résultats du calcul de Implements
Implements (FB_Test) = 2
Implements (FB_Base) = 1
EIO0000004079.02
71
Machine Code Analysis
Métriques
Métrique : Lines Of Code (LOC)
User Description
La métrique LOC compte le nombre de lignes de code source dans un
programme. Elle détermine ainsi la taille du programme. Cette métrique peut être
utilisée pour estimer la charge représentée par le développement du programme,
sa mise en production et la maintenance du logiciel publié.
Metric Calculation
Chaque ligne d'un objet implémenté textuel (fonction (FUN), bloc fonction (FB),
type d'unité de donnée (DUT), liste de variables globales (GVL), etc.) est prise en
compte dans la métrique Lines Of Code.
Exemple
Exemple de calcul de la métrique LOC pour du code IEC-61131-3 :
Declaration:
1: PROGRAM SR_Main
2: VAR
3:
x: BOOL;
4: END_VAR
Implementation:
1:
2: IF (x = TRUE) THEN
3:
DoSomething();
4: END_IF
5:
6: // A nice comment
7: SpecialMethod();
Résultat de la métrique LOC
Lines Of Code (LOC) = 11
Métrique : Memory Size (Data)
User Description
Une application ou une bibliothèque basée sur IEC-61131-3 s'articule autour de
types complexes tels que des programmes, des blocs fonction, des listes de
variables globales, des méthodes, des actions, des fonctions, des structures, etc.
Au sein de chacun de ces types, des variables peuvent être définies.
Les types complexes blocs fonction et structures peuvent être instanciés plusieurs
fois et placés en bloc dans la mémoire.
Chaque définition de type complexe (informations de type et variables), lors de
son instanciation, a besoin d'une certaine quantité de mémoire appelée son
empreinte. Cette empreinte est utilisée pour obtenir les informations concernant la
taille nécessaire dans la mémoire elle-même. Informations sur la quantité de
mémoire à gérer, par exemple dans des situations de modification en ligne ou lors
de l'utilisation en tant qu'argument d'entrée de méthodes (informations utilisées
ensuite comme taille de pile). Elle peut aussi être utilisée pour identifier des types
complexes volumineux qui peuvent poser des problèmes s'ils sont souvent
instanciés, par exemple dans un tableau (array).
Metric Calculation
Pour un bloc fonction ou une structure, les tailles des variables sont additionnées.
Le type bloc fonction a de plus besoin de mémoire (liste de méthodes, interfaces
implémentées, etc.). Selon l'architecture de contrôleur sous-jacente, un
72
EIO0000004079.02
Métriques
Machine Code Analysis
alignement de mémoire doit également être envisagé. Il s'appuie sur le type et
l'ordre des variables.
Exemple
Exemple de calcul de Memory Size (Data) pour du code IEC-61131-3 :
FUNCTION_BLOCK FB_XXX
VAR
xVar1: BOOL; // 1 bit
xVar2: BOOL; // 1 bit
xVar3: BOOL; // 1 bit
// 5 additional bits for alignment
iVar4: INT; // 4 byte (on 32-bit architectures)
xVar5: BOOL; // 1 bit
// 7 additional bits for alignment
fbComplex: FB_Test; // 20 byte
END_VAR
FUNCTION_BLOCK FB_YYY
VAREND_VAR
FUNCTION_BLOCK FB_ZZZ
VAR
iVar1: INT;
END_VAR
Résultats du calcul de Memory Size (Data)
Memory Size (Data) (FB_XXX) = 32
Memory Size (Data) (FB_YYY) = 4
Memory Size (Data) (FB_ZZZ) = 8
Métrique : Number Of Actions
User Description
La métrique Number Of Actions est utilisée pour obtenir des informations sur le
nombre d'actions associées à un programme ou à un bloc fonction.
Metric Calculation
Toute action associée à un programme ou à un bloc fonction est prise en compte.
Les actions non utilisées sont également comptabilisées.
Exemple
Exemple de calcul de Number Of Actions pour du code IEC-61131-3 :
FB_MyAlphaModule
- ACT_InitAxis1 (Action)
- ACT_InitAxis2 (Action)
- UpdateStatus (Method)
- Calculate (Method)
- Enabled (Property)
- Get (Property Get)
- Set (Property Set)
- Status (Property)
- Get (Property Get)
- Set (Property Set)
- SwitchNextState (Transition)
Résultat du calcul de Number Of Actions (pour la variable FB_
MyAlphaModule)
Number Of Actions = 2
EIO0000004079.02
73
Machine Code Analysis
Métriques
Métrique : Number Of GVL Usages
User Description
La métrique Number Of GVL Usages est utilisée pour obtenir des informations sur
le nombre de variables globales utilisées (en lecture ou en écriture) par un objet
de programmation (programme, bloc fonction, fonction, méthode, etc.).
Metric Calculation
Chaque objet de programmation (programme, bloc fonction, fonction, méthode,
obtention ou définition de propriété, etc.) est traité individuellement.
Exemple
Exemple de calcul de Number Of GVL Usages pour du code IEC-61131-3 :
FB_MyAlphaModule
VAR
iMyState : INT;
END_VAR
iMyState := GVL_IOs.G_iState;
if (iMyState = 10) THEN
;
END_IF
Résultat du calcul de Number Of GVL Usages (pour la variable FB_
MyAlphaModule)
Number Of GVL Usages = 1
Métrique : nombre de lignes de commentaire en en-tête
User Description
Cette métrique compte le nombre de commentaires dans l'en-tête de la section
déclarative.
Ces commentaires peuvent aider les développeurs à comprendre ce que fait
l'objet, à quelle fin et de quelle manière.
Metric Calculation
Chaque ligne de commentaire apparaissant dans l'en-tête d'une section
déclarative au sein d'objets IEC (fonction (FUN), bloc fonction (FB), type d'unité
de données (DUT), liste de variables globales (GVL), etc.) est comptabilisée.
Exemple
Exemple de calcul des commentaires en en-tête pour du code IEC-61131-3 :
Declaration:
1: //This PRG is the start point
2: //Methodes:
3: // - ....
4: // - ....
5: PROGRAM SR_Main
6: VAR
7:
x: BOOL;
8: END_VAR
Nombre de commentaires en en-tête : 4
74
EIO0000004079.02
Métriques
Machine Code Analysis
Métrique : Number Of Instances
User Description
La métrique Number Of Instances est utilisée pour obtenir des informations sur la
fréquence d'utilisation d'un type complexe (bloc fonction, énumération, structure,
etc.) en tant que type variable dans des objets de programmation (programmes,
blocs fonction, etc.).
Metric Calculation
Vous pouvez déclarer des variables dans la section de déclaration. Un type de
données (complexe ou élémentaire) est associé à chaque variable. Pour chaque
utilisation, le nombre d'instances de ce type de données est augmenté d'une
unité.
NOTE: Si le type de données de la variable est un tableau (array), le type de
données sous-jacent est utilisé et le nombre d'instances est augmenté de 1.
La longueur du tableau n'est pas prise en compte.
NOTE: Les chemins d'instanciation à travers différents types complexes ne
sont pas pris en compte. Par exemple, si un bloc fonction est instancié
plusieurs fois, les types complexes inclus ne sont comptés qu'une seule fois.
Exemple
Exemple de calcul de Number Of Instances pour du code IEC-61131-3 :
SR_Main
VAR
fbMyAlphaModule: FB_MyAlphaModule;
END_VAR
FB_MyAlphaModule
VAR
astAxisStructures: ARRAY [1..10] OF ST_MyAxisStructure;
fbSubModule: FB_MySubModule;
END_VAR
FB_MySubModule
VAR
fbAxis: FB_MyAxis;
END_VAR
ST_MyAxisStructure
VAR
iID: INT;
fbAxis: FB_MyAxis;
END_VAR
FB_MyAxis
VAR
END_VAR
Résultats du calcul de Number Of Instances
Number Of Instances (FB_MyAlphaModule) = 1
Number Of Instances (FB_MySubModule) = 1
Number Of Instances (ST_MyAxisStructure) = 1
Number Of Instances (FB_MyAxis) = 2
Métrique : Number Of Library References
User Description
La métrique Number Of Library References est utilisée pour obtenir des
informations sur le nombre de bibliothèques référencées directement par un
espace d'application ou de POU.
EIO0000004079.02
75
Machine Code Analysis
Métriques
Metric Calculation
Toutes les références d'application à bibliothèque ou de bibliothèque à
bibliothèque sont prises en compte.
Exemple
Exemple de calcul de Number Of Library References pour du code IEC-61131-3 :
Application
--> Library A
--> Library B
--> Library B
--> Library C
Résultat du calcul de Number Of Library References (pour l'application)
Number Of Library References = 3
Métrique : Number Of Messages
User Description
La métrique Number Of Messages (simple information, avertissement, erreur
détectée, erreur irrécupérable) est utilisée pour obtenir des informations sur le
nombre de messages envoyés à la Vue Messages pendant la compilation.
Metric Calculation
La plupart des messages concernent un objet de programmation (bloc fonction,
fonction, etc.). Tout message qui n'est pas lié à un objet de programmation est
attaché à l'application (ou à l'espace POU en cas d'analyse de l'espace POU
uniquement).
NOTE: L'analyse du code est basée sur une application compilable exempte
d'erreurs de compilation. Les messages de catégorie erreur et erreur
irrécupérable émis pendant la compilation ne peuvent pas se produire dans
les données d'analyse.
Métrique : Number Of Methods
User Description
La métrique Number Of Methods est utilisée pour obtenir des informations sur le
nombre de méthodes associées à un programme ou à un bloc fonction.
Metric Calculation
Toute méthode associée à un programme ou à un bloc fonction est prise en
compte. Les méthodes non utilisées sont également comptabilisées.
Exemple
Exemple de calcul de Number Of Methods pour du code IEC-61131-3 :
FB_MyAlphaModule
- ACT_InitAxis1 (Action)
- ACT_InitAxis2 (Action)
- UpdateStatus (Method)
- Calculate (Method)
- Enabled (Property)
- Get (Property Get)
- Set (Property Set)
- Status (Property)
- Get (Property Get)
- Set (Property Set)
76
EIO0000004079.02
Métriques
Machine Code Analysis
- SwitchNextState (Transition)
Résultat du calcul de Number Of Methods (pour la variable FB_
MyAlphaModule)
Number Of Methods = 2
Métrique : nombre de commentaires multilignes
User Description
Cette métrique compte les commentaires multilignes dans un objet IEC.
L'utilisation de commentaires multilignes n'est pas une bonne pratique car le
début et la fin de ces commentaires risquent de se perdre lors d'une fusion.
Par exemple, un code source isolé en commentaire peut être accidentellement
réinséré dans le programme.
Metric Calculation
Exemple
Exemple de calcul des commentaires multilignes pour du code IEC-61131-3 :
Declaration:
1: (*This is a multiline
2: comment in header*)
3: PROGRAM SR_Main
4: VAR
5:
xCheck1: BOOL;(*not needed
6:
uiMyVariable2: UINT;*)
7:
xFlag: BOOL;
8: END_VAR
Nombre de commentaires multilignes : 2
Métrique : Number Of Properties
User Description
La métrique Number Of Properties est utilisée pour obtenir des informations sur le
nombre de propriétés associées à un programme ou à un bloc fonction.
Metric Calculation
Toute propriété associée à un programme ou à un bloc fonction est prise en
compte. Les propriétés non utilisées sont également comptabilisées.
Exemple
Exemple de calcul de Number Of Properties pour du code IEC-61131-3 :
FB_MyAlphaModule
- ACT_InitAxis1 (Action)
- ACT_InitAxis2 (Action)
- UpdateStatus (Method)
- Calculate (Method)
- Enabled (Property)
- Get (Property Get)
- Set (Property Set)
- Status (Property)
- Get (Property Get)
- Set (Property Set)
- SwitchNextState (Transition)
EIO0000004079.02
77
Machine Code Analysis
Métriques
Résultat du calcul de Number Of Properties (pour la variable FB_
MyAlphaModule)
Number Of Properties = 2
Métrique : Number Of Reads
User Description
La métrique Number of Reads est utilisée pour obtenir des informations sur les
variables qui ont été lues.
Metric Calculation
Chaque lecture d'une variable dans une implémentation est prise en compte, mais
si une même variable est lue deux fois dans une implémentation, elle est comptée
une seule fois.
Exemple
Exemple de calcul de Number Of Reads pour du code IEC-61131-3 :
METH(iMyVariable);
// Some other implementation
METH(iMyVariable);
Résultat du calcul de Number Of Reads (pour la variable iMyVariable)
Number Of Reads = 1
Métrique : Number Of Tasks
User Description
La métrique Number Of Tasks est utilisée pour obtenir des informations sur le
nombre de tâches actuellement définies dans une application.
Metric Calculation
Les tâches ne peuvent être définies que dans des applications. La métrique
renvoie le nombre de tâches définies dans une application.
Exemple
Exemple de calcul de Number Of Tasks pour du code IEC-61131-3 :
Application
- SR_Main (Program)
- FB_Test1 (FunctionBlock)
- FB_Test2 (FunctionBlock)
- TaskConfiguration
- TASK_SR_Main (Task)
- TASK_Visu (Task
Résultat du calcul de Number Of Tasks (pour l'application)
Number Of Tasks = 2
78
EIO0000004079.02
Métriques
Machine Code Analysis
Métrique : Number Of Transitions
User Description
La métrique Number Of Transitions est utilisée pour obtenir des informations sur
le nombre de transitions associées à un programme ou à un bloc fonction.
Metric Calculation
Toute transition associée à un programme ou à un bloc fonction est prise en
compte. Les transitions non utilisées sont également comptabilisées.
Exemple
Exemple de calcul du nombre de transitions pour du code IEC-61131-3 :
FB_MyAlphaModule
- ACT_InitAxis1 (Action)
- ACT_InitAxis2 (Action)
- UpdateStatus (Method)
- Calculate (Method)
- Enabled (Property)
- Get (Property Get)
- Set (Property Set)
- Status (Property)
- Get (Property Get)
- Set (Property Set)
- SwitchNextState (Transition)
Résultat du calcul de Number Of Transitions (pour la variable FB_
MyAlphaModule)
Number Of Properties = 2
Métrique : Number Of Variables
User Description
La métrique Number Of Variables est utilisée pour obtenir des informations sur le
nombre de variables définies dans la section de déclaration de programmes,
blocs fonction, fonctions, méthodes, commandes Get ou Set de propriétés,
transitions, listes de variables globales, etc.
Metric Calculation
Toute variable définie dans une section de déclaration est prise en compte. Les
variables non utilisées sont également comptabilisées.
Exemple
Exemple de calcul de Number Of Variables pour du code IEC-61131-3 :
FB_MyAlphaModule
VAR
i: INT;
END_VAR
VAR_INPUT
i_iCommand: INT;
i_lrPosition: LREAL;
END_VAR
VAR_OUTPUT
q_iStatus: INT;
END_VAR
Résultat du calcul de Number Of Variables (pour la variable FB_
MyAlphaModule)
Number Of Variables = 4
EIO0000004079.02
79
Machine Code Analysis
Métriques
Métrique : Number Of Writes
User Description
La métrique Number Of Writes est utilisée pour obtenir des informations sur les
variables qui ont été écrites.
Metric Calculation
Chaque écriture d'une variable dans une implémentation est prise en compte,
mais si une même variable est écrite deux fois dans une implémentation, elle est
comptée une seule fois.
Exemple
Exemple de calcul de Number Of Writes pour du code IEC-61131-3 :
iMyVariable := 1;
// Some other implementation
iMyVariable := 2;
Résultat du calcul de Number Of Writes (pour la variable iMyVariable)
Number Of Writes = 1
Métrique : Number Of FBD Networks
User Description
La métrique Number of Function Block Diagram (FBD) Networks est utilisée pour
obtenir des informations sur le nombre de réseaux disponibles dans un
programme, un bloc fonction, une fonction, une méthode ou une propriété
implémentés en FBD.
Metric Calculation
Chaque réseau FBD disponible dans le programme, le bloc fonction, la fonction, la
méthode ou la propriété est pris en compte.
Exemple
Exemple de calcul de la métrique Number Of FBD Networks :
FB_MyAlphaModule (FB) - implemented in FBD
- FBD Network 1
- FBD Network 2
- FBD Network 3
Résultat de la métrique Number Of FBD Networks (pour la variable FB_
MyAlphaModule)
Number Of FBD Networks = 3
Métrique : taux de commentaires dans le code source
User Description
Les commentaires peuvent aider les développeurs à comprendre ce que fait le
code, à quelle fin et de quelle manière.
Cette métrique calcule le rapport (unité : %) entre CLOC (Comment Lines Of
Code) et SLOC (Source Lines Of Code) dans la section d'implémentation d'un
objet IEC.
80
EIO0000004079.02
Métriques
Machine Code Analysis
CLOC : nombre de lignes de commentaire, y compris les lignes combinant code
source et commentaire.
SLOC : nombre de lignes sans commentaire et de lignes vides, y compris les
lignes combinant code source et commentaire.
Metric Calculation
Chaque ligne d'un objet implémenté textuel (fonction (FUN), bloc fonction (FB),
type d'unité de données (DUT), programme (PRG), etc.) est analysée pour vérifier
si elle contient un commentaire ou du code source.
Cette métrique fournit le rapport entre les deux valeurs.
Exemple
Exemple de calcul du taux de commentaires du code source pour du code IEC61131-3 :
1:
2: IF (x = TRUE) THEN
3:
DoSomething();//This is very important and hard to
understand
4: END_IF
5:
6: // A nice comment
7: SpecialMethod();
Taux de commentaires dans le code source : 50 %
Métrique : Stack Size
User Description
Une application ou une bibliothèque basée sur IEC-61131-3 s'articule autour de
types complexes tels que des programmes, des blocs fonction, des listes de
variables globales, des méthodes, des actions, des fonctions, des structures, etc.
Au sein de chacun de ces types, des variables peuvent être définies.
Lorsqu'un type complexe est appelé, par exemple une fonction, une méthode, une
action, une opération Get ou Set de propriété ou une transition, l'exécution
nécessite la mémoire de la pile. Les informations de taille de pile peuvent être
utilisées pour identifier le type complexe qui consomme une quantité trop
importante de mémoire de la pile.
NOTE: La mémoire de pile disponible par tâche est limitée et définie par le
contrôleur utilisé. Une consommation importante de la taille de la pile peut
entraîner des exceptions.
NOTE: Si un type de bloc fonction est utilisé comme type de variable d'entrée
de méthode (appel par valeur), la taille mémoire du type complexe est
nécessaire (voir Données de taille mémoire, page 72). L'appel par valeur ne
doit pas être utilisé pour les types complexes tels que les entrées de méthode
ou de fonction.
Metric Calculation
Pour un type complexe tel qu'une fonction ou une méthode, les tailles des
variables s'additionnent. Lors de l'appel du type complexe, la taille mémoire est
allouée par dessus la pile et les valeurs d'entrée y sont copiées. Pendant
l'exécution du code de la fonction ou de la méthode, ces valeurs de mémoire sont
utilisées.
NOTE: Chaque appel de méthode ou de fonction a sa propre mémoire et
aucun conflit ne se produit si une méthode est appelée en parallèle par une
autre tâche.
Exemple
EIO0000004079.02
81
Machine Code Analysis
Métriques
Exemple de calcul de Stack Size pour du code IEC-61131-3 :
FUNCTION_BLOCK FB_XXX
VAR
fbComplex: FB_Test; // 20 byte
END_VAR
// method call of FB_XXX
Meth1(TRUE);
METHOD Meth1
VAR_INPUT
xTest1: BOOL;
END_VARVAR
iTest2: INT;
END_VAR
METHOD METH2
VAR_INPUT
fbComp: FB_XXX;
END_VAR
Résultats du calcul de Stack Size
Stack Size (METH1) = 8
Stack Size (METH2) = 32
82
EIO0000004079.02
Conventions
Machine Code Analysis
Conventions
Contenu de ce chapitre
Requêtes de convention ................................................................................83
Convention : messages de compilation ...........................................................86
Convention : POU complexe avec faible taux de commentaires ........................86
Conventions : Vérifications des noms de types complexes ...............................87
Conventions : Limite de profondeur d'héritage .................................................87
Convention : vérification de lecture de variable d'entrée ...................................88
Convention : vérification du type de variable d'entrée .......................................89
Convention : vérification d'écriture de variable d'entrée ....................................89
Convention : utilisation de commentaires multilignes........................................90
Convention : absence de commentaire en en-tête............................................91
Conventions : Nombre limite de méthodes ......................................................91
Conventions : Nombre limite de propriétés ......................................................91
Convention : vérification de lecture de variable de sortie...................................92
Convention : vérification du type de variable de sortie ......................................93
Convention : vérification d'utilisation de variables PERSISTENT .......................93
Convention : vérification d'utilisation de variables RETAIN ................................93
Convention : variable non commentée (toutes) ................................................94
Convention : variable non commentée (entrée+sortie+globale) .........................94
Conventions : Vérification des variables inutilisées...........................................94
Conventions : Vérification des noms de variable ..............................................95
Conventions : Vérification de la longueur des noms de variable ........................96
Requêtes de convention
Requêtes de convention
Les requêtes suivantes sont disponibles par défaut avec l'installation
d'EcoStruxure Machine Expert.
Groupe : Comment Checks
Nom
Complex POU With Low Comment Ratio
Multiline Comments Usage
No Header Comment
Uncommented Variable (All)
Uncommented Variable (In+Out+Global)
Groupe : Complex Type Name Checks
EIO0000004079.02
•
Vérifiez que les objets définis par l'utilisateur respectent les règles
configurées.
•
Par exemple, les énumérations doivent commencer par ET_ (exemple : ET_
MyTestEnumeration).
Nom
Préfixe
Complex Type Name (Enumeration)
ET_
Complex Type Name (Function)
FC_
Complex Type Name (Function block)
FB_
Complex Type Name (Interface)
IF_
Complex Type Name (Program)
SR_
83
Machine Code Analysis
Conventions
Nom
Préfixe
Complex Type Name (Struct)
ST_
Complex Type Name (TestCase)
TC_
Complex Type Name (TestResource)
TR_
Complex Type Name (TestSeries)
TS_
Complex Type Name (TestSet)
TS_
Complex Type Name (Union)
UT_
Groupe : Messages
Nom
Compile Messages
Groupe : Variable Name Checks (Complex Types) et Variable Name Checks (Elementary
Types)
84
•
La portée (local, entrée, sortie, entrée/sortie, etc.) et le type de données
doivent être indiqués comme préfixes dans les noms de variables. Exemple :
q_ pour les variables d'entrée et ar pour les variables de type tableau -> q_
arMyVariable.
•
Les guides de style de codage recommandent d'ajouter des préfixes aux
variables.
Nom
Préfixe
Variable Name (Array)
ar
Variable Name (Enumeration)
et
Variable Name (FunctionBlock)
fb
Variable Name (Interface)
if
Variable Name (Pointer)
p
Variable Name (Reference)
r
Variable Name (Struct)
st
Variable Name (TestCase)
tc
Variable Name (Union)
ut
Nom
Préfixe
Variable Name (BIT)
x
Variable Name (BOOL)
x
Variable Name (BYTE)
b
Variable Name (DATE)
dat
Variable Name (DINT)
di
Variable Name (DT)
dt
Variable Name (DWORD)
dw
Variable Name (INT)
i
Variable Name (LINT)
li
Variable Name (LREAL)
lr
Variable Name (LTIME)
ltim
Variable Name (LWORD)
lw
EIO0000004079.02
Conventions
Machine Code Analysis
Nom
Préfixe
Variable Name (REAL)
r
Variable Name (SINT)
si
Variable Name (STRING)
s
Variable Name (TOD)
tod
Variable Name (UDINT)
udi
Variable Name (UINT)
ui
Variable Name (ULINT)
uli
Variable Name (USINT)
usi
Variable Name (WORD)
w
Variable Name (WSTRING)
ws
Groupe : Threshold Checks
Nom
Description
Inheritance Depth Limit
Description : cette requête permet de vérifier, pour chaque interface ou bloc fonction, que la
profondeur d'héritage ne dépasse pas la limite fixée.
Cas d'utilisation : vous pouvez vérifier la limite de profondeur d'héritage pour éviter d'avoir des
structures trop complexes ou trop profondes qui seraient impossibles à gérer.
Exemple : le bloc fonction 1 étend le bloc 2, qui étend le bloc 3, lequel étend le bloc 4.
Variable Length Check
Description : cette requête permet de vérifier, pour chaque variable, que la longueur ne dépasse
pas la limite suggérée.
Cas d'utilisation : vous pouvez vérifier la longueur des noms de variables pour rendre le code
source plus lisible et facile à gérer.
Exemple à suivre : iCounterVariable1
Exemple à proscrire : iAnotherToLengthCounter1Variable
Number Of Method Limit
Description : cette requête permet de vérifier, pour un bloc fonction par exemple, que le nombre
de méthodes définies ne dépasse pas la limite suggérée.
Cas d'utilisation : lorsqu'un bloc fonction contient trop de méthodes, il convient de le remanier
pour n'implémenter qu'une seule fonction.
Number Of Properties Limit
Description : cette requête permet de vérifier, pour un bloc fonction par exemple, que le nombre
de propriétés définies ne dépasse pas la limite suggérée.
Cas d'utilisation : lorsqu'un bloc fonction contient trop de propriétés, il convient de le remanier
pour n'implémenter qu'une seule fonction.
Groupe : Usage Checks
Nom
Description
Input Variable Read Check
Description : cette requête permet de vérifier, pour chaque variable d'entrée, si elle est lue
depuis l'extérieur du POU.
Cas d'utilisation : les guides de style de codage déconseillent de lire une variable d'entrée d'un
POU.
Input Variable Type Check
Description : cette requête permet de vérifier, pour chaque variable d'entrée, si elle est de type
bloc fonction.
Cas d'utilisation : les guides de style de codage déconseillent d'utiliser des variables d'entrée de
type bloc fonction.
Input Variable Writes Check
Description : cette requête permet de vérifier, pour chaque variable d'entrée, si elle est écrite à
partir du POU dans lequel elle est définie.
Cas d'utilisation : les guides de style de codage déconseillent d'écrire dans une variable d'entrée
depuis un POU.
Output Variable Read Check
EIO0000004079.02
Description : cette requête permet de vérifier, pour chaque variable de sortie, si elle est lue à
partir du POU.
85
Machine Code Analysis
Nom
Conventions
Description
Cas d'utilisation : les guides de style de codage déconseillent de lire une variable de sortie à
partir d'un POU.
Output Variable Type Check
Description : cette requête permet de vérifier, pour chaque variable de sortie, si elle est de type
bloc fonction.
Cas d'utilisation : les guides de style de codage déconseillent d'utiliser des variables de sortie de
type bloc fonction.
Persistant Usage Check
Description : cette requête permet de vérifier, pour chaque variable, si elle est de type
PERSISTANT et si elle est déclarée dans un bloc fonction.
Cas d'utilisation : les guides de style de codage déconseillent d'utiliser des variables
PERSISTANT dans les blocs fonction.
Retain Usage Check
Description : cette requête permet de vérifier, pour chaque variable, si elle est de type RETAIN
et si elle est déclarée dans un bloc fonction.
Cas d'utilisation : les guides de style de codage déconseillent d'utiliser des variables RETAIN
dans les blocs fonction.
Unused Variables Check
Description : cette requête permet de vérifier si certaines variables ne sont ni lues, ni écrites
dans le projet entier (-> variable inutilisée).
Cas d'utilisation : vous pouvez détecter les variables inutilisées et générer un rapport les
concernant, nettoyer le projet et améliorer ainsi la qualité du code.
Convention : messages de compilation
User Description
Lors de la compilation d'une application basée sur IEC-61131-3, le compilateur
signale au développeur les erreurs irrécupérables et les erreurs détectées, des
conseils (avertissements) et diverses informations utiles.
Les erreurs irrécupérables et les erreurs détectées doivent être résolues par le
développeur pour que l'application puisse fonctionner sur un contrôleur.
Les avertissements à titre de conseil doivent aussi être traités par le développeur.
Leur nombre doit être aussi proche de zéro que possible pour une application
dont la publication est déjà planifiée.
Les messages simplement informatifs servent notamment à tenir le développeur
au courant de l'évolution de l'application compilée ou de ses besoins en taille
mémoire.
NOTE: Il n'est possible de procéder à une analyse de code que sur une
application exempte d'erreurs irrécupérables. Seuls les messages de
compilation sont pris en compte lors d'une analyse de code. Les messages
d'erreur ne sont pas disponibles.
Convention Verification Rule
Pour la vérification des conventions, les messages de compilation disponibles
(données d'analyse complètes) sont pris en compte et signalés. La gravité des
messages de compilation est utilisée comme pondération de la violation de
convention.
Convention : POU complexe avec faible taux de commentaires
User Description
Cette convention dresse la liste de tous les objets IEC complexes à faible taux de
commentaires.
86
EIO0000004079.02
Conventions
Machine Code Analysis
Contrairement à d'autres métriques qui ne s'intéressent qu'au rapport entre CLOC
(Comment Lines Of Code) et SLOC (Source Lines Of Code), cette convention
permet de filtrer les objets IEC présentant une grande complexité et un faible taux
de commentaires.
Cette convention se concentre uniquement sur la partie implémentation d'un objet
IEC.
Conventions : Vérifications des noms de types complexes
User Description
Coding style is a set of rules or guidelines applied when writing source code.
Following a specified coding style helps:
•
To read and understand the source code.
•
To avoid and find programming issues.
•
To easy maintenance of source code.
Sur la base des instructions de programmation (conventions de nom (voir
EcoStruxure Machine Expert, Programming Guide), préfixes (voir EcoStruxure
Machine Expert, Programming Guide)) de Schneider Electric pour le code source
IEC-61131-3, il existe des interrogations de conventions pour vérifier les noms de
types complexes suggérés pour chaque type.
Convention Verification Rule
Pour la vérification de convention, le type complexe est combiné avec le nom
d'objet.
Préfixes de nom en fonction des types complexes :
•
Bloc fonction : préfixe FB_
•
Programme : préfixe SR_
•
Enumération : préfixe ET_
•
Structure : préfixe ST_
•
...
Exemple
FB_MyAxisWrapper
ST_MyDataStruct
ET_MyEnumeration
SR_Main
...
Conventions : Limite de profondeur d'héritage
User Description
La norme IEC-61131-3 fournit des fonctionnalités de langage pour étendre des
blocs fonction ou implémenter des interfaces. On parle alors d'héritage, et il peut
se former des héritages en chaîne. En théorie, la profondeur d'héritage n'est pas
limitée. En pratique, les imbrications peuvent devenir trop complexes pour
permettre une bonne compréhension de l'arbre généalogique des interfaces et
des blocs fonction.
Pour faciliter la maintenance des applications, il est possible d'appliquer et de
signaler une limite de profondeur d'héritage à l'aide de règles de violation de
convention.
EIO0000004079.02
87
Machine Code Analysis
Conventions
Convention Verification Rule
Le mot-clé extends est utilisé entre blocs fonction ou entre interfaces pour vérifier
la longueur de la chaîne.
Exemple
La profondeur d'héritage est 6 pour cet exemple.
FB_Test1 extends FB_Test2
FB_Test2 extends FB_Test3
FB_Test3 extends FB_Test4
FB_Test4 extends FB_Test5
FB_Test5 extends FB_Test6
FB_Test6 extends FB_Test7
Convention : vérification de lecture de variable d'entrée
User Description
In the declaration part of a program, function block, method, or function, input
variables can be defined. When objects of this type are called, input values must
be specified. When a method or a function is called, the input values are copied to
the stack. These values (memory area) are only used by the method or function
call.
Compared to programs where exactly one instance exists in memory (or function
blocks which are instantiated multiple times in memory), the programs or function
blocks can be called multiple times, by multiple tasks, and the same memory
location for the input variable is used (in parallel).
Pour garantir la stabilité d'exécution des applications, une variable d'entrée ne doit
pas être lue depuis l'extérieur du programme ou du bloc fonction (implémentation
du corps).
NOTE: Gardez à l'esprit que l'accès à une variable d'entrée depuis une
méthode définie sous un bloc fonction est également considéré comme un
accès depuis l'extérieur de ce bloc fonction. En effet, le corps du bloc fonction
n'est pas nécessairement appelé au moins une fois avant l'appel d'une
méthode depuis l'extérieur de ce bloc fonction et l'affectation du contenu
correct aux variables d'entrée. La violation de la convention Variable Read
Check d'entrée peut être un faux positif si le développeur, par exemple, vérifie
par révision du code que la variable d'entrée est correctement initialisée avant
de l'utiliser dans une méthode.
Convention Verification Rule
Chaque accès en lecture à une variable d'entrée depuis l'extérieur de
l'implémentation du corps du bloc fonction ou du programme lui-même est signalé
en tant que violation de convention.
Exemple
SR_Main
VAR
fbTest: FB_Test;
END_VAR
// call of FB method without calling FB (Body) before
fbTest.Meth();
FB_Test
VAR_INPUT
i_lrCurrentAxisPosition: LREAL;
88
EIO0000004079.02
Conventions
Machine Code Analysis
END_VAR
METHOD Meth()
VAR
i_lrVar1: LREAL;
END_VAR
// potential access to not properly initialized variable
i_lrVar1 := i_lrCurrentAxisPosition;
Convention : vérification du type de variable d'entrée
User Description
Des variables d'entrée peuvent être définies dans la section déclarative d'un POU.
Lorsque ce POU est appelé, des valeurs d'entrées doivent être spécifiées.
Ces valeurs d'entrée sont copiées par valeur (copie mémoire).
Pour assurer la stabilité d'exécution de l'application, la variable d'entrée ne doit
pas être de type bloc fonction.
Convention Verification Rule
Toute variable d'entrée de type bloc fonction est signalée comme violation de
convention.
Exemple
SR_Main
VAR
fbTest: FB_Test;
fbArg: FB_MyArg;
END_VAR
// call of FB method without calling FB (Body) before
fbTest(i_fbMyArg := fbArg);
FB_MyArg
VAR_INPUT
END_VAR
FB_Test
VAR_INPUT
i_fbMyArg: FB_MyArg;
END_VAR
Convention : vérification d'écriture de variable d'entrée
User Description
In the declaration part of a program, function block, method, or function, input
variables can be defined. When objects of this type are called, input values must
be specified. When a method or a function is called, the input values are copied to
the stack. These values (memory area) are only used by the method or function
call.
Compared to programs where exactly one instance exists in memory (or function
blocks which are instantiated multiple times in memory), the programs or function
blocks can be called multiple times, by multiple tasks, and the same memory
location for the input variable is used (in parallel).
EIO0000004079.02
89
Machine Code Analysis
Conventions
Pour assurer la stabilité d'exécution des applications, la variable d'entrée doit être
écrite uniquement par le demandeur (de l'extérieur) du programme ou du bloc
fonction.
NOTE: La catégorie des variables d'entrée signifie que les données sont
envoyées vers la structure considérée, qu'il s'agisse d'un programme, d'un
bloc fonction, d'une méthode ou d'une fonction. Les résultats de l'appel sont
de la catégorie sortie. Les variables d'entrée doivent se limiter à celles
transmises à la structure et les entrées ne doivent pas être lues ni écrites
depuis l'extérieur de cette structure.
Convention Verification Rule
Chaque accès en écriture à une variable d'entrée depuis l'intérieur du bloc
fonction (implémentation du corps) lui-même est signalé en tant que violation de
convention.
Exemple
SR_Main
VAR
fbTest: FB_Test;
END_VAR
// call of FB method without calling FB (Body) before fbTest
(TRUE);
FB_Test
VAR_INPUT
i_xEnable: BOOL;
END_VAR
// potential violation. Now the input value has changed its
value.
i_xEnable := FALSE;
Convention : utilisation de commentaires multilignes
User Description
Cette convention vérifie si des commentaires multilignes sont utilisés dans les
objets IEC.
L'utilisation de commentaires multilignes n'est pas une bonne pratique car le
début et la fin de ces commentaires risquent de se perdre lors d'une fusion.
Par exemple, un code isolé en commentaire peut être accidentellement réinséré
dans le programme.
Exemple
Exemple de calcul des commentaires multilignes pour du code IEC-61131-3.
Déclaration :
1: (*This is a multiline
2: comment in header*)
3: PROGRAM SR_Main
4: VAR
5:
xCheck1: BOOL;(*not needed
6:
uiMyVariable2: UINT;*)
7:
xFlag: BOOL;
8: END_VAR
90
EIO0000004079.02
Conventions
Machine Code Analysis
Convention : absence de commentaire en en-tête
User Description
De nombreux guides de style de codage préconisent la présence d'une
description générale de l'action et du fonctionnement d'un POU dans l'en-tête de
la section déclarative.
Exemple
Toutes les variantes de commentaires sont comptablisées pour cette vérification :
- //my comment
- ///my doc comment
- (*my multi line comment*)
Conventions : Nombre limite de méthodes
User Description
IEC-61131-3 propose des fonctionnalités de langage pour organiser les
applications en programmes et blocs fonction. Aux fins de simplification et de
prise en charge de l'orientation objet, chacun de ces éléments peuvent être
fractionnés en morceaux de code pouvant être appelés et réutilisés plusieurs fois.
Cela produit des méthodes, actions, propriétés etc. attachées à des programmes
ou à des blocs fonction.
Pour faciliter la maintenance des applications, il existe des principes de base
concernant l'organisation du code. Par exemple, limitez chaque bloc fonction ou
méthode à une tâche.
L'application de règles de conception de code peut notamment permettre de
détecter que trop de méthodes sont rattachées au même bloc fonction et, par
conséquent, d'inciter à fractionner ce bloc fonction en plusieurs morceaux de
code.
Convention Verification Rule
Cette métrique permet de vérifier si le nombre limite de méthodes rattachées à un
bloc fonction ou un programme est dépassé.
Conventions : Nombre limite de propriétés
User Description
IEC-61131-3 fournit des fonctionnalités de langage pour organiser une application
en programmes, blocs fonction et listes de variables globales (GVL). Pour réduire
la complexité et prendre en charge l'orientation objet, des propriétés peuvent être
jointes. Chaque propriété fournit un accès fonctionnel aux informations qu'elle
recouvre.
Un nombre excessif de propriétés jointes :
•
Est difficile à gérer, voire à comprendre, pour le développeur.
•
Peut entraîner des conflits de noms.
•
Peut être le signe qu'un programme ou un bloc fonction réalise plusieurs
tâches.
Le résultat de cette convention peut être utilisé comme une incitation à fractionner
un programme/bloc fonction en plusieurs programmes/blocs fonction exécutant
chacun une seule tâche.
EIO0000004079.02
91
Machine Code Analysis
Conventions
La maintenance des applications peut s'en trouver facilitée.
Convention Verification Rule
Le nombre de propriétés attachées à un bloc fonction, un programme ou une liste
de variables globales (GVL) est utilisé pour vérifier si la limite est dépassée.
Convention : vérification de lecture de variable de sortie
User Description
Dans la section de déclaration d'un programme, d'un bloc fonction, d'une méthode
ou d'une fonction, il est possible de définir des variables de sortie. Lorsque des
objets de ce type sont appelés, des valeurs cibles de sortie peuvent être
spécifiées. Lors de l'appel d'une méthode ou d'une fonction, les valeurs de sortie
sont copiées dans la pile. Ces valeurs (zone de mémoire) sont attribuées
uniquement par l'appel de méthode ou de fonction et elles sont réutilisées par
l'appelant.
Compared to programs where exactly one instance exists in memory (or function
blocks which are instantiated multiple times in memory), the programs or function
blocks can be called multiple times, by multiple tasks, and the same memory
location for the input variable is used (in parallel).
Pour assurer la stabilité d'exécution des applications, la variable de sortie doit être
lue uniquement par le demandeur (de l'extérieur) du programme ou du bloc
fonction.
NOTE: La lecture d'une variable de sortie à partir d'une implémentation peut
être un faux positif, par exemple si le développeur vérifie par révision du code
que la variable de sortie est correctement écrite avant de l'utiliser
ultérieurement dans le code.
Convention Verification Rule
Chaque accès en lecture à une variable de sortie depuis l'intérieur du bloc
fonction (implémentation du corps) lui-même est signalé en tant que violation de
convention car il n'est pas possible de vérifier qu'une valeur correcte a été
affectée antérieurement.
Exemple
SR_Main
VAR
xResult: BOOL;
fbTest: FB_Test;
END_VAR
// call of FB method without calling FB (Body) before fbTest
(q_xEnable => xResult);
FB_Test
VAR_OUTPUT
q_xEnable: BOOL;
END_VAR
// potential violation. Now the input value has changed its
value.
IF (q_xEnable) THEN
; // Violation. Unclear value of output variable.
END_IF
92
EIO0000004079.02
Conventions
Machine Code Analysis
Convention : vérification du type de variable de sortie
User Description
Des variables de sortie peuvent être définies dans la section déclarative d'un
POU. Lorsque ce POU est appelé, des valeurs de sortie peuvent être affectées.
Ces valeurs de sortie sont copiées par valeur (copie mémoire).
Pour assurer la stabilité d'exécution de l'application, la variable de sortie ne doit
pas être de type bloc fonction.
Convention Verification Rule
Toute variable de sortie de type bloc fonction est signalée comme violation de
convention.
Exemple
SR_Main
VAR
fbTest: FB_Test;
fbArg: FB_MyArg;
END_VAR
// call of FB method without calling FB (Body) before
fbTest(q_fbMyArg => fbArg);
FB_MyArg
VAR_INPUT
END_VAR
FB_Test
VAR_OUTPUT
q_fbMyArg: FB_MyArg;
END_VAR
Convention : vérification d'utilisation de variables PERSISTENT
User Description
Si vous déclarez une variable en tant que PERSISTENT dans un bloc fonction,
toute l'instance de ce bloc fonction est enregistrée dans la plage persistante
(toutes les données du bloc), mais seule la variable PERSISTENT déclarée est
restaurée.
Cette consommation accrue de mémoire et les autres contraintes de gestion des
variables persistantes peuvent entraîner des problèmes de performance.
NOTE: Le compilateur traite une déclaration VAR PERSISTENT comme une
déclaration VAR PERSISTENT RETAIN ou VAR RETAIN PERSISTENT.
Convention : vérification d'utilisation de variables RETAIN
User Description
Si vous déclarez une variable en tant que RETAIN dans un bloc fonction, toute
l'instance de ce bloc fonction est enregistrée dans la plage conservée (toutes les
données du bloc), mais seule la variable RETAIN déclarée est restaurée.
Cette consommation accrue de mémoire et les autres contraintes de gestion des
variables conservées peuvent entraîner des problèmes de performance.
EIO0000004079.02
93
Machine Code Analysis
Conventions
Convention : variable non commentée (toutes)
User Description
Cette convention vérifie s'il existe des variables non commentées dans un objet
IEC.
Exemple
Exemple de variables non commentées pour du code IEC-61131-3.
Déclaration :
1: PROGRAM SR_Main
2: VAR
3:
xCheck1: BOOL;//flag to identify
4:
uiMyVariable2: UINT;
5:
xFlag: BOOL;
6: END_VAR
Les variables uiMyVariable2 et xFlag ne sont pas commentées. Une violation de
convention est donc créée.
Convention : variable non commentée (entrée+sortie+globale)
User Description
Cette convention vérifie s'il existe dans le code source des variables non
commentées définies dans VAR_GLOBAL, VAR_INPUT, VAR_OUTPUT ou VAR_
IN_OUT.
Exemple
Exemple de variable non commentée pour du code IEC-61131-3.
Déclaration :
1: PROGRAM SR_Main
2: VAR_IN
3:
i_xCheck1: BOOL;//flag to identify
3:
i_uiMyVariable2: UINT;
4: END_VAR
2: VAR
3:
xFlag: BOOL;
4: END_VAR
i_uiMyVariable2 n'est pas commentée. Une violation de convention est donc
créée.
Conventions : Vérification des variables inutilisées
User Description
Dans la section de déclaration d'un programme, d'un bloc fonction, d'une méthode
ou d'une fonction, il est possible de définir des variables. Normalement, ces
variables sont utilisées à l'intérieur du code. Si une variable définie n'est pas
utilisée (lue ou écrite) dans le code, elle consomme de la mémoire.
Convention Verification Rule
Chaque variable ne présentant aucun accès en lecture ou en écriture est signalée
comme une violation de convention.
94
EIO0000004079.02
Conventions
Machine Code Analysis
Exemple
SR_Main
VAR
xMyUnusedVariableResult: BOOL;
fbTest: FB_Test;
END_VAR
// call of FB method but output is not assigned to intended
result variable.
fbTest(q_xEnable => );
Conventions : Vérification des noms de variable
User Description
Coding style is a set of rules or guidelines applied when writing source code.
Following a specified coding style helps:
•
To read and understand the source code.
•
To avoid and find programming issues.
•
To easy maintenance of source code.
Sur la base des instructions de programmation (conventions de noms (voir
EcoStruxure Machine Expert, Programming Guide), préfixes (voir EcoStruxure
Machine Expert, Programming Guide)) de Schneider Electric pour le code source
IEC-61131-3, il existe des interrogations de conventions pour vérifier le nom de
variable suggéré par type de données et par portée (domaine de validité).
Convention Verification Rule
Pour la vérification de convention, le nom de la variable est combiné avec le type
de données associé et le domaine de validité dans lequel la variable est définie.
Portées :
•
Portée de variable locale : pas de préfixe de portée spécial (VAR ... END_
VAR)
•
Portée de variable d'entrée : préfixe i_ (VAR_INPUT ... END_VAR)
•
Portée de variable de sortie : préfixe q_ (VAR_OUTPUT ... END_VAR)
•
Portée de variable d'entrée/sortie : préfixe iq (VAR_IN_OUT_ ... END_VAR)
•
Portée de variable globale : préfixe G_
•
Portée de constante globale : préfixe Gc_
•
...
Préfixes de nom de variable en fonction du type de données :
•
INT : préfixe i
•
DINT : préfixe di
•
UDINT : préfixe udi
•
REAL : préfixe r
•
LREAL : préfixe lr
•
Bloc fonction : préfixe fb
•
POINTER TO : préfixe p
•
...
Exemple
VAR
iMyVariable1: INT;
EIO0000004079.02
95
Machine Code Analysis
Conventions
uiMyVariable1: UINT;
rMyVariable1: REAL;
piMyVariable7: POINTER TO INT;
END_VAR
VAR_INPUT
i_iMyVariable2: INT;
i_uiMyVariable2: UINT;
i_rMyVariable2: REAL;
END_VAR
VAR_IN_OUT
iq_iMyVariable3: INT;
iq_uiMyVariable3: UINT;
iq_rMyVariable3: REAL;
END_VAR
VAR_OUTPUT
iq_iMyVariable2: INT;
iq_uiMyVariable2: UINT;
iq_rMyVariable2: REAL;
END_VAR
Conventions : Vérification de la longueur des noms de variable
User Description
Coding style is a set of rules or guidelines applied when writing source code.
Following a specified coding style helps:
•
To read and understand the source code.
•
To avoid and find programming issues.
•
To easy maintenance of source code.
Pour des raisons de lisibilité du code, il existe des suggestions concernant les
noms de variable et leur longueur. La longueur des variables peut être vérifiée par
rapport à une limite définie par l'utilisateur.
Convention Verification Rule
La longueur d'un nom de variable est comparée à un seuil limite.
Exemple
iMyVariable
OK
iSpecialAndVeryLongAndHardToReadVariable
Not OK
96
// length 11 -->
// length 20 -->
EIO0000004079.02
Machine Code Analysis
Index
A
absence de commentaire en en-tête
conventions .......................................................91
analyse de code
commandes de menu contextuel (navigateurs).....38
objets de script ..................................................42
analyse du code
extensions des objets de script ...........................41
Instructions Pragma ...........................................39
interface de création de scripts............................41
analyse du code machine
concept de base ................................................13
généralités ........................................................ 11
C
call in
métriques ..........................................................62
call out
métriques ..........................................................62
code analysis editors
liste de blocage..................................................25
commandes de menu contextuel (navigateurs)
analyse de code.................................................38
comment afficher les dépendances via la vue de
dépendance
vue de dépendance............................................50
comment ajouter
éditeurs d'analyse de code .................................47
comment avoir un aperçu rapide
tableau de bord..................................................47
comment explorer étape par étape les dépendances
de votre application
vue de dépendance............................................51
comment obtenir des résultats détaillés sur les
conventions
tableau des conventions .....................................49
comment obtenir des résultats détaillés sur les
métriques
tableau des mesures ..........................................48
concept de base
analyse du code machine ...................................13
configuration
gestionnaire d'analyse de code ...........................28
connexion au cloud
gestionnaire d'analyse de code ...........................29
gestionnaire de requêtes d'analyse de code.........37
conventions
absence de commentaire en en-tête....................91
limite de profondeur d'héritage ............................87
Machine Advisor Code Analysis ..........................83
messages de compilation ...................................86
nombre limite de méthodes.................................91
nombre limite de propriétés.................................91
POU complexe avec faible taux de
commentaires ..................................................86
utilisation de commentaires multilignes ................90
variable non commentée (entrée+sortie
+globale) .........................................................94
variable non commentée (toutes) ........................94
vérification d'écriture de variable d'entrée.............89
vérification d'utilisation de variables
PERSISTENT ..................................................93
vérification d'utilisation de variables RETAIN ........93
vérification de la longueur des noms de variable...96
EIO0000004079.02
vérification de lecture de variable d'entrée............88
vérification de lecture de variable de sortie...........92
vérification des noms de variable.........................95
vérification des variables inutilisées .....................94
vérification du type de variable d'entrée ...............89
vérification du type de variable de sortie...............93
vérifications des noms de types complexes..........87
cyclomatic complexity
métriques ..........................................................63
E
éditeur de paramètres
gestionnaire de requêtes d'analyse de code.........37
éditeur de paramètres de chaînes de requête
gestionnaire de requêtes d'analyse de code.........36
éditeur de requêtes
gestionnaire de requêtes d'analyse de code.........35
éditeurs d'analyse de code.....................................17
comment ajouter ................................................47
présentation (vue de dépendance) ......................20
tableau des conventions .....................................17
tableau des mesures ..........................................18
vue de dépendance (commandes du menu
contextuel).......................................................22
vue de dépendance (filtres).................................20
vue de dépendance (graphe de dépendance) ......21
vue de dépendance (groupes).............................23
extended by
métriques ..........................................................65
extends
métrique............................................................65
extensions des objets de script
analyse du code.................................................41
F
fan in
métriques ..........................................................66
fan out
métriques ..........................................................66
G
généralités
analyse du code machine ................................... 11
gestionnaire d'analyse de code ..............................27
configuration......................................................28
connexion au cloud ............................................29
tableau de bord..................................................27
gestionnaire de requêtes d'analyse de code ............31
connexion au cloud ............................................37
éditeur de paramètres ........................................37
éditeur de paramètres de chaînes de requête.......36
éditeur de requêtes ............................................35
jeux de règles ....................................................31
référentiels de requêtes ......................................32
requêtes de convention ......................................83
requêtes de dépendance (filtre)...........................54
requêtes de dépendance (sélection)....................56
graphe de dépendance
ajouter une variable............................................38
H
Halstead complexity
métriques ..........................................................67
97
Machine Code Analysis
I
implemented by
métriques ..........................................................70
implements
métriques ..........................................................71
instructions Pragma
analyse du code.................................................39
interface de création de scripts
analyse du code.................................................41
J
jeux de règles
gestionnaire de requêtes d'analyse de code.........31
L
limite de profondeur d'héritage
conventions .......................................................87
lines of code
métriques ..........................................................72
liste de blocage
éditeurs d'analyse de code .................................25
M
Machine Advisor Code Analysis
conventions .......................................................83
métriques ..........................................................60
memory size
métriques ..........................................................72
messages de compilation
conventions .......................................................86
métrique
call out ..............................................................62
extends .............................................................65
métriques
call in ................................................................62
cyclomatic complexity.........................................63
extended by.......................................................65
fan in.................................................................66
fan out...............................................................66
Halstead complexity ...........................................67
implemented by .................................................70
implements........................................................71
lines of code ......................................................72
Machine Advisor Code Analysis ..........................60
memory size ......................................................72
nombre de commentaires multilignes...................77
nombre de lignes de commentaire en en-tête .......74
number of actions ..............................................73
Number Of FBD Networks ..................................80
number of GVL usages.......................................74
number of instances ...........................................75
number of library references ...............................75
number of messages..........................................76
number of methods ............................................76
number of properties ..........................................77
number of reads.................................................78
number of tasks .................................................78
number of transitions..........................................79
number of variables............................................79
number of writes ................................................80
stack size ..........................................................81
taille de l'application (code) .................................60
taille de l'application (code+données) ..................61
taille de l'application (données) ...........................61
98
taux de commentaires dans le code source..........80
taux de variables commentées (entrée+sortie
+globale) .........................................................63
taux de variables commentées (toutes)................62
N
nombre de commentaires multilignes
métriques ..........................................................77
nombre de lignes de commentaire en en-tête
métriques ..........................................................74
nombre limite de méthodes
conventions .......................................................91
nombre limite de propriétés
conventions .......................................................91
number of actions
métriques ..........................................................73
Number Of FBD Networks
métriques ..........................................................80
number of GVL usages
métriques ..........................................................74
number of instances
métriques ..........................................................75
number of library references
métriques ..........................................................75
number of messages
métriques ..........................................................76
number of methods
métrique............................................................76
number of properties
métriques ..........................................................77
number of reads
métriques ..........................................................78
number of tasks
métriques ..........................................................78
number of transitions
métriques ..........................................................79
number of variables
métriques ..........................................................79
number of writes
métriques ..........................................................80
O
objets de script
analyse de code.................................................42
P
POU complexe avec faible taux de commentaires
conventions .......................................................86
présentation (vue de dépendance)
éditeurs d'analyse de code .................................20
R
référentiels de requêtes
gestionnaire de requêtes d'analyse de code.........32
requêtes de convention
gestionnaire de requêtes d'analyse de code.........83
requêtes de dépendance (filtre)
gestionnaire de requêtes d'analyse de code.........54
requêtes de dépendance (sélection)
gestionnaire de requêtes d'analyse de code.........56
EIO0000004079.02
Machine Code Analysis
S
stack size
métriques ..........................................................81
T
tableau de bord
comment avoir un aperçu rapide .........................47
gestionnaire d'analyse de code ...........................27
tableau des conventions
comment obtenir des résultats détaillés sur les
conventions .....................................................49
éditeurs d'analyse de code .................................17
tableau des mesures
comment obtenir des résultats détaillés sur les
métriques ........................................................48
éditeurs d'analyse de code .................................18
taille de l'application (code)
métriques ..........................................................60
taille de l'application (code+données)
métriques ..........................................................61
taille de l'application (données)
métriques ..........................................................61
taux de commentaires dans le code source
métriques ..........................................................80
taux de variables commentées (entrée+sortie+globale)
métriques ..........................................................63
taux de variables commentées (toutes)
métriques ..........................................................62
comment explorer étape par étape les dépendances
de votre application ..........................................51
vue de dépendance (commandes du menu
contextuel)
éditeurs d'analyse de code .................................22
vue de dépendance (filtres)
éditeurs d'analyse de code .................................20
vue de dépendance (graphe de dépendance)
éditeurs d'analyse de code .................................21
vue de dépendance (groupes)
éditeurs d'analyse de code .................................23
U
utilisation de commentaires multilignes
conventions .......................................................90
V
variable au graphique de dépendance ....................38
variable non commentée (entrée+sortie+globale)
conventions .......................................................94
variable non commentée (toutes)
conventions .......................................................94
vérification d'écriture de variable d'entrée
conventions .......................................................89
vérification d'utilisation de variables PERSISTENT
conventions .......................................................93
vérification d'utilisation de variables RETAIN
conventions .......................................................93
vérification de la longueur des noms de variable
conventions .......................................................96
vérification de lecture de variable d'entrée
conventions .......................................................88
vérification de lecture de variable de sortie
conventions .......................................................92
vérification des noms de variable
conventions .......................................................95
vérification des variables inutilisées
conventions .......................................................94
vérification du type de variable d'entrée
conventions .......................................................89
vérification du type de variable de sortie
conventions .......................................................93
vérifications des noms de types complexes
conventions .......................................................87
vue de dépendance
comment afficher les dépendances via la vue de
dépendance.....................................................50
EIO0000004079.02
99
Schneider Electric
35 rue Joseph Monier
92500 Rueil Malmaison
France
+ 33 (0) 1 41 29 70 00
www.se.com
Les normes, spécifications et conceptions pouvant changer de temps à
autre, veuillez demander la confirmation des informations figurant dans
cette publication.
© 2020 – Schneider Electric. Tous droits réservés.
EIO0000004079.02