WinCC Configuration Manual - Siemens AG · Configuration Manual Manuel tome 1 ... 3.2.10 Convention: Les procédures d'alarme ... 4.5.2 Exemple 2 – Boucle do-while

WinCC

Configuration Manual

Manuel tome 1

Ce manuel est livré avec la documentationréférencée :6AV6392-1CA05-0AC0C79000-G8277-C157-01

Edition Septembre 1999

WinCC®, SIMATIC®, SIMATIC NET®, SINEC® et STEP® sont des marques de la société Siemens AG.

Les autres désignations dans ce manuel peuvent être des marques de fabrique dont l'utilisation par un tiers àces mêmes fins peuvent léser droits du détenteur.

(Toute reproduction de ce support d’informations, touteexploitation de son contenu sont interdites, sauf autorisationexpresse. Tout manquement à cette règle est illicite et exposeson auteur au versement de dommages et intérêts. Tous nosdroits sont réservés, notamment pour le cas de la délivranced'un brevet ou celui de l'enregistrement d'un modèle d'utilité.)

(Nous avons vérifié que le contenu de ce manuel correspondaux éléments matériels et logiciels qui y sont décrits. Desdivergences ne sont cependant pas exclues ce qui nousempêche de garantir une correspondance totale. Lesinformations fournies dans cet imprimé sont vérifiéesrégulièrement, les corrections nécessaires sont insérées dansl'édition suivante. Nous vous sommes reconnaissants pourtoute proposition d'amélioration.)

Siemens AG 1994 - 1999 All rights reserved Sous réserve de modifications techniques

C79000-G8277-C157Printed in the Federal Republic of Germany Siemens Aktiengesellschaft

WinCC Configuration Manual iC79000-G8277-C157-01

Table des matières

1 Manuel de configuration ........................................................... 1-11.1 Manuel de configuration - Remarques sur la structure et l’utilisation du

manuel............................................................................................ 1-2

2 WinCC - Remarques générales ................................................ 2-12.1 Le concept WinCC ......................................................................... 2-22.1.1 Les interfaces de WinCC ............................................................... 2-3

2.2 Les termes de WinCC et leur signification ..................................... 2-5

3 Configuration - Thèmes généraux ........................................... 3-13.1 Avant de commencer la configuration............................................ 3-2

3.2 Conventions ................................................................................... 3-33.2.1 Convention: Nom de projet WinCC................................................ 3-43.2.2 Convention: Noms de variables ..................................................... 3-53.2.3 Convention: Noms de vues............................................................ 3-73.2.4 Convention: Scripts et actions........................................................ 3-93.2.5 Convention: L’interface utilisateur .................................................. 3-103.2.6 Convention: Le concept de commande ......................................... 3-153.2.7 Convention: Le paramétrage des couleurs .................................... 3-173.2.8 Convention: Les cycles de rafraîchissement ................................. 3-18

3.2.9 Convention: Les autorisations d'accès........................................... 3-193.2.10 Convention: Les procédures d'alarme ........................................... 3-203.2.11 Convention: Réalisation ................................................................. 3-21

3.3 Particularits de la configuration avec WinCC................................. 3-22

3.3.1 Cycles de rafrachissement - O et comment paramtrer ? ............... 3-233.3.1.1 Le rafraîchissement des vues ........................................................ 3-243.3.1.2 Types de cycles de rafraîchissement............................................. 3-253.3.1.3 Signification des cycles de rafraîchissement ................................. 3-273.3.1.4 Remarques sur l'utilisation des cycles de rafraîchissement .......... 3-273.3.1.5 Exécution de scripts en arrière-plan (Global Script) ...................... 3-34

3.3.2 Dynamisation WinCC ..................................................................... 3-383.3.2.1 Dynamisation des propriétés.......................................................... 3-383.3.2.2 Dynamisation des événements...................................................... 3-393.3.2.3 Types de dynamisation des objets................................................. 3-39

3.3.3 Environnement systme WinCC ...................................................... 3-423.3.3.1 Structure des répertoires de WinCC .............................................. 3-42

3.3.4 Environnement de projet WinCC.................................................... 3-453.3.4.1 Projet WinCC - Structure de répertoires ........................................ 3-45

3.3.5 Démarrage automatique de projet WinCC..................................... 3-483.3.6 Sortie coordonne de WinCC .......................................................... 3-513.3.7 Sauvegarde des données .............................................................. 3-52

Table des matières 09.99

ii WinCC Configuration ManualC79000-G8277-C157-01

3.3.8 Copier un projet WinCC sauvegardé sur une nouvelle machinecible ................................................................................................ 3-54

3.3.9 Rutilisation - Reprise de parties de projet dans un nouveau projet ou dansun projet existant............................................................................ 3-56

3.3.9.1 Réutilisation de vues ...................................................................... 3-573.3.9.2 Réutilisation de symboles et de bitmaps........................................ 3-593.3.9.3 Réutilisation de symboles d'une bibliothèque de projet (de symboles et

d'objets utilisateur préconfigurés) .................................................. 3-603.3.9.4 Réutilisation d'actions..................................................................... 3-623.3.9.5 Réutilisation de variables ............................................................... 3-633.3.9.6 Réutilisation de textes multilingues (de vues, d'alarmes) .............. 3-703.3.9.7 Réutilisation d'alarmes ................................................................... 3-713.3.9.8 Réutilisation de valeurs de mesure................................................ 3-74

3.3.9.9 Réutilisation de modèles de travaux d'impression......................... 3-743.3.9.10 Réutilisation d'actions globales ...................................................... 3-743.3.9.11 Réutilisation de fonctions de projet ................................................ 3-743.3.9.12 Utilisation de fonctions standard .................................................... 3-743.3.9.13 Réutilisation de la gestion des utilisateurs ..................................... 3-74

3.3.10 Commande sans souris ................................................................. 3-753.3.10.1 Commande au clavier .................................................................... 3-753.3.10.2 Déplacements par objets de manipulation (champs de saisie et champs de

commande) .................................................................................... 3-793.3.10.3 Touches de fonction Alarm Logging pour boutons de barre

d'outils ............................................................................................ 3-813.3.10.4 Boutons de barre d'outils configurés de manière spécifique au process

dans Alarm Logging ....................................................................... 3-833.3.10.5 Touches de fonction Tag Logging pour boutons de barre d'outils. 3-843.3.10.6 Lancement de travail d'impression................................................. 3-863.3.10.7 Connexion ou déconnexion système ............................................. 3-87

3.3.11 Technique des composants de vues ............................................. 3-883.3.11.1 Boîtes d'information de process comme composant de vues........ 3-893.3.11.2 Composant de vue à adressage indirect ....................................... 3-913.3.11.3 bjets utilisateur ............................................................................... 3-923.3.11.4 istance dynamique ......................................................................... 3-933.3.11.5 Vues prototypes ............................................................................. 3-943.3.11.6 Objets OCX .................................................................................... 3-97

3.3.12 Configuration en ligne (runtime) - Remarques, restrictions ........... 3-99

4 Cours de programmation en C ................................................. 4-14.1 Environnement de dveloppement de scripts C .............................. 4-34.1.1 Editeur d'actions de Graphics Designer......................................... 4-44.1.2 Editeur Global Script ...................................................................... 4-11

4.2 Variables ........................................................................................ 4-174.2.1 Exemple 1 – Types de données de C (nombres entiers) ............. 4-194.2.2 Exemple 2 – Types de données définis par l'utilisateur

(nombres entiers) ........................................................................... 4-214.2.3 Exemple 3 - Variables WinCC (nombres entiers) ......................... 4-234.2.4 Exemple 4 – Types de données C (nombres à virgule flottante).. 4-25

09.99 Table des matières

WinCC Configuration Manual iiiC79000-G8277-C157-01

4.2.5 Exemple 5 - Variables WinCC (nombres à virgule flottante) ........ 4-264.2.6 Exemple 6 – Variables statiques et variables externes ................ 4-27

4.3 Opérateurs et fonctions mathématiques dans C............................ 4-294.3.1 Exemple 1 - Opérations arithmétiques........................................... 4-314.3.2 Exemple 2 – Opérateur d'incrémentation et opérateur de

décrémentation............................................................................... 4-324.3.3 Exemples 3 - Opérations sur bits.................................................. 4-344.3.4 Exemple 4 – Permutation d'octets ................................................. 4-364.3.5 Exemple 5 – Fonctions mathématiques........................................ 4-37

4.4 Pointeurs ........................................................................................ 4-394.4.1 Exemple 1 – Pointeur.................................................................... 4-414.4.2 Exemple 2 – Vecteurs ................................................................... 4-424.4.3 Exemple 3 – Pointeurs et vecteurs ............................................... 4-434.4.4 Exemple 4 – Chaînes de caractères (strings)............................... 4-454.4.5 Exemple 5 – Variables de texte WinCC........................................ 4-46

4.5 Boucles et instructions conditionnelles .......................................... 4-474.5.1 Exemple 1 – Boucle while ............................................................. 4-494.5.2 Exemple 2 – Boucle do-while........................................................ 4-504.5.3 Exemple 3 – Boucle for ................................................................. 4-514.5.4 Exemple 4 – Boucles sans fin ....................................................... 4-524.5.5 Exemple 5 – Instruction if-else ...................................................... 4-544.5.6 Exemple 6 – Instruction switch-case............................................. 4-55

4.6 Fonctions........................................................................................ 4-564.6.1 Exemple 1 – Passage de paramètres par valeur........................... 4-574.6.2 Exemple 2 – Passage de paramètres par adresse........................ 4-594.6.3 Ecriture dans un vecteur transmis.................................................. 4-614.6.4 Renvoi de l'adresse du résultat...................................................... 4-63

4.7 Structures....................................................................................... 4-654.7.1 Exemple 1 – Structure................................................................... 4-664.7.2 Exemple 2 – Définition de type de structure ................................. 4-674.7.3 Exemple 3 – Type de structure WinCC......................................... 4-694.7.4 Exemple 4 – Fonction de lecture d'un type de structure WinCC ... 4-71

4.8 API WinCC ..................................................................................... 4-744.8.1 Exemple 1 – Modification de propriétés avec la fonction RT........ 4-764.8.2 Exemple 2 – Création d'une liaison à une variable avec

fonction RT..................................................................................... 4-784.8.3 Exemple 3 – Création d'un nouvel objet avec une fonction CS.... 4-804.8.4 Exemple 4 – Modification de propriétés avec fonction CS ........... 4-824.8.5 Exemple 5 – Création d'une liaison à une variable avec

fonction CS..................................................................................... 4-844.8.6 Exemple 6 – Listage d'objets avec fonction CS............................. 4-86

4.9 Environnement de projet ................................................................ 4-894.9.1 Exemple 1 – Recherche de fichier de projet ................................. 4-904.9.2 Exemple 2 – Recherche du chemin de projet ............................... 4-914.9.3 Exemple 3 – Recherche du chemin d'un projet par fonction

de projet ......................................................................................... 4-934.9.4 Exemple 4 – Recherche du répertoire d'installation ..................... 4-95


iv WinCC Configuration ManualC79000-G8277-C157-01

4.9.5 Exemple 5 – Recherche de nom d'ordinateur............................... 4-974.9.6 Exemple 6 – Recherche du nom de l'utilisateur............................ 4-98

4.10 API Windows.................................................................................. 4-994.10.1 Exemple 1 – Configuration de propriétés de fenêtre .................... 4-1004.10.2 Exemple 2 – Lecture de l'heure système...................................... 4-1014.10.3 Exemple 3 – Exécution de fichiers son ......................................... 4-1024.10.4 Exemple 4 – Lancement d'un programme .................................... 4-103

4.11 Dialogues standard ........................................................................ 4-1044.11.1 Exemple 1 – Changement de langue............................................ 4-1054.11.2 Exemple 2 – Sélection de variable................................................ 4-1074.11.3 Exemple 3 – Boîte de message d'erreur....................................... 4-1094.11.4 Exemple 4 – Boîte de questions ................................................... 4-1104.11.5 Exemple 5 – Dialogue standard Ouvrir ......................................... 4-111

4.12 Fichiers........................................................................................... 4-1144.12.1 Exemple 1 - Sauvegarder des données........................................ 4-1164.12.2 Exemple 2 - Lire des données dans un fichier.............................. 4-1174.12.3 Exemple 3 - Journalisation............................................................ 4-118

4.13 Dynamic Wizard ............................................................................. 4-1204.13.1 Création de fonctions Dynamik Wizard propres à l'utilisateur........ 4-1214.13.2 Structure d'une fonction Dynamik Wizard ...................................... 4-122

5 Annexe........................................................................................ 5-15.1 Trucs et astuces............................................................................. 5-25.1.1 Entrée/Sortie normalisée dans champ E/S .................................... 5-35.1.2 Actions agissant sur des objets à la sélection de vue ................... 5-45.1.3 WinCC-Scope................................................................................. 5-5

5.1.4 Accs la base de donnes ................................................................ 5-65.1.4.1 Accès à la base de données depuis Excel/MSQuery .................... 5-65.1.4.2 Accès à la base de données depuis Access.................................. 5-95.1.4.3 Accès à la base de données depuis ISQL..................................... 5-105.1.4.4 Accès à la base de données depuis WinCC-Scope ...................... 5-115.1.4.5 Exportation depuis une base de données par actions C ............... 5-125.1.4.6 Sélections de base de données..................................................... 5-13

5.1.5 Couplage série ............................................................................... 5-145.1.6 Tableaux des couleurs ................................................................... 5-15

5.2 Documentation du systme d'alarmes S5........................................ 5-165.2.1 Liste des blocs du logiciel .............................................................. 5-175.2.2 Prérequis matériels ........................................................................ 5-18

5.2.3 Intgration du systme d'alarmes S5 au programme utilisateurSIMATIC S5 ................................................................................... 5-19

5.2.3.1 Structure du bloc de données d'offset............................................ 5-215.2.3.2 Numéro d'alarme de base.............................................................. 5-225.2.3.3 Numéro d'alarme d'offset / Etats de signal des alarmes................ 5-225.2.3.4 Bloc d'états signal .......................................................................... 5-245.2.3.5 Adresse du dernier bloc d'état de signal ........................................ 5-245.2.3.6 Etats de signal................................................................................ 5-25


WinCC Configuration Manual vC79000-G8277-C157-01

5.2.3.7 Etats de repos ................................................................................ 5-255.2.3.8 Bits d’acquittement ......................................................................... 5-265.2.3.9 Mémentos de front ......................................................................... 5-265.2.3.10 Structure du bloc de données de paramètres................................ 5-265.2.3.11 Structure d'un bloc d'alarmes......................................................... 5-275.2.3.12 Numéro d'alarme............................................................................ 5-285.2.3.13 Etat d'alarme .................................................................................. 5-285.2.3.14 Horodatage (Time Stamp).............................................................. 5-285.2.3.15 Variable de process ....................................................................... 5-295.2.3.16 Numéro de contrat / Etiquette de charge ....................................... 5-295.2.3.17 Réserve .......................................................................................... 5-295.2.3.18 Génération d'un bloc d'alarmes...................................................... 5-295.2.3.19 Le tampon cyclique interne (FIFO) ................................................ 5-295.2.3.20 Le bloc interface - pour transmission des données au système

WinCC............................................................................................ 5-30

5.2.4 Description d'interface.................................................................... 5-315.2.4.1 Bloc de données système 80......................................................... 5-315.2.4.2 Bloc de données d'offset ................................................................ 5-315.2.4.3 Bloc de données de paramètres .................................................... 5-315.2.4.4 Bloc interface.................................................................................. 5-31

5.2.5 Paramétrage du système d'alarmes S5 / DB Système 80............. 5-325.2.6 Exemple de configuration pour le systme d'alarmes S5 ................ 5-375.2.6.1 Paramétrage du DB 80 .................................................................. 5-375.2.6.2 Paramétrage des blocs de données .............................................. 5-385.2.6.3 Initialisation des blocs de données d'offset.................................... 5-38

5.2.7 Documentation des blocs de commandes SIMATIC S5................ 5-425.2.7.1 Liste des blocs logiciels.................................................................. 5-425.2.7.2 Matériel requis................................................................................ 5-435.2.7.3 Paramètres d'appel de FB 87: EXECUTE ..................................... 5-43

5.2.8 Description d'interface.................................................................... 5-445.2.8.1 Exemple de configuration des blocs de commandes S5 ............... 5-46

5.2.9 Fonction de la synchronisation d'heure S5 .................................... 5-475.2.9.1 Liste des blocs logiciels.................................................................. 5-475.2.9.2 Matériel requis................................................................................ 5-47

5.2.10 Paramètres d'appel de FB 86 : MELD:UHR................................... 5-48

5.2.11 Formats de données pour la date et l'heure .................................. 5-505.2.11.1 Zone de données d'heure CPU 944, CPU 945.............................. 5-515.2.11.2 Zone de données d'heure CPU 928B, CPU 948 ........................... 5-525.2.11.3 Zone de données d'heure CPU 946, CPU 947.............................. 5-535.2.11.4 Format de données d'heure pour blocs d'alarmes......................... 5-53

5.2.12 Description d'interface.................................................................... 5-555.2.13 Interaction entre WinCC et le système d'alarmes.......................... 5-56

5.3 DLL de normalisation pour interfaage vers AlarmLogging etTagLogging .................................................................................... 5-57

5.3.1 Interface commune vers AlarmLogging et TagLogging ................. 5-58


vi WinCC Configuration ManualC79000-G8277-C157-01

5.3.2 Compléments spécifiques à TagLogging....................................... 5-60

5.3.3 Fonctions API d'une DLL de normalisation WinCC ....................... 5-615.3.3.1 Initialisation de la DLL de normalisation ........................................ 5-615.3.3.2 Interrogation des propriétés d'une DLL de normalisation .............. 5-625.3.3.3 Interrogation du nom de la DLL de normalisation.......................... 5-64

5.3.4 Fermeture de la DLL de normalisation........................................... 5-655.3.4.1 Extensions de la configuration ....................................................... 5-655.3.4.2 Extension du dialogue pour la configuration des alarmes S7PMC 5-655.3.4.3 Extension du dialogue de configuration de variables d'archive ..... 5-665.3.4.4 Services en ligne............................................................................ 5-685.3.4.5 Enregistrement de toutes les variables d'archive .......................... 5-695.3.4.6 Changement de langue.................................................................. 5-71

5.3.5 Normalisation ................................................................................. 5-725.3.5.1 Dérivation d'alarmes individuelles.................................................. 5-725.3.5.2 Acquittement, verrouillage, déverrouillage d'alarmes .................... 5-735.3.5.3 Traitement au changement d'état .................................................. 5-745.3.5.4 Mise à jour d'alarmes par la DLL de normalisation S7PMC .......... 5-745.3.5.5 Normalisation de variables d'archive ............................................. 5-745.3.5.6 Dérivation de valeurs de variables d'archives................................ 5-755.3.5.7 Verrouillage / déverrouillage de variables d'archive ...................... 5-765.3.5.8 Traitement au changement d'état .................................................. 5-76

5.4 Bibliothque globale......................................................................... 5-775.4.1 Blocs de process............................................................................ 5-785.4.1.1 Moteurs .......................................................................................... 5-785.4.1.2 PC /API........................................................................................... 5-795.4.1.3 Pompes .......................................................................................... 5-795.4.1.4 Tuyauterie ...................................................................................... 5-805.4.1.5 Tuyauterie – Objets utilisateur ....................................................... 5-805.4.1.6 Cuves ............................................................................................. 5-815.4.1.7 Robinet objets utilisateur................................................................ 5-815.4.1.8 Robinets ......................................................................................... 5-81

5.4.2 Affichage ........................................................................................ 5-825.4.2.1 Affichage ........................................................................................ 5-825.4.2.2 Fenêtres ......................................................................................... 5-825.4.2.3 Echelle............................................................................................ 5-825.4.2.4 Champs de texte ............................................................................ 5-825.4.2.5 Instruments à index........................................................................ 5-83

5.4.3 Commande..................................................................................... 5-845.4.3.1 Boutons tridimensionnels ............................................................... 5-845.4.3.2 Pupitres de commande .................................................................. 5-845.4.3.3 Boutons de vue .............................................................................. 5-855.4.3.4 Navigation dans vue....................................................................... 5-855.4.3.5 Boutons Incr./Décr. ........................................................................ 5-865.4.3.6 Régulateurs .................................................................................... 5-865.4.3.7 Changement de langue.................................................................. 5-865.4.3.8 Claviers .......................................................................................... 5-865.4.3.9 Boutons de basculement................................................................ 5-87


WinCC Configuration Manual viiC79000-G8277-C157-01

5.4.4 Symboles........................................................................................ 5-885.4.4.1 Robinets d’isolement ...................................................................... 5-885.4.4.2 Registres ........................................................................................ 5-895.4.4.3 DIN 30600 ...................................................................................... 5-905.4.4.4 Symboles E .................................................................................... 5-915.4.4.5 Bandes transporteuses .................................................................. 5-925.4.4.6 Symboles ISA................................................................................. 5-935.4.4.7 Moteurs .......................................................................................... 5-975.4.4.8 Robinets ......................................................................................... 5-985.4.4.9 Divers ............................................................................................. 5-995.4.4.10 Divers 2 .......................................................................................... 5-100


viii WinCC Configuration ManualC79000-G8277-C157-01

Préface

Objectifs du manuel

Ce manuel expose les possibilités de configuration de WinCC et comprend les parties présentées ci-dessous:

• WinCC – Remarques generales

• Configuration – Themes generalux

• Cours de programmation en C

• Annexe

Ce manuel existe sous forme papier et de document online.La table des matières et l'index permettent de trouver rapidement les informations recherchées. Ledocument online possède une fonction de recherche étendue.

Prérequis pour l'utilisation de ce manuel

Connaissances de base de WinCC, acquises p. ex. par la lecture de Getting Started ou expériencepratique de la configuration avec WinCC.

Autres formes d’assistance

Pour toutes questions techniques, contactez votre interlocuteur à la représentation ou à l'établissementSiemens.Notre assistance téléphonique a le numéro:

49 (911) 895-7000 (Fax 7001)

Informations sur les produits SIMATIC

Des informations mises à jour régulièrement sur les produits SIMATIC figurent au catalogue CA01.Vous pouvez le consulter à l'adresse Internet:

http://www.ad.siemens.de/ca01online/

Notre Support Clients vous fournit des informations récentes et des possibilités de téléchargement.Les réponses aux questions les plus fréquemment posées sont disponibles à l'adresse:

http://www.ad.siemens.de/support/html_00/index.shtml

09.99 Manuel de configuration

WinCC Configuration Manual 1-1C79000-G8277-C157-01

1 Manuel de configurationLe manuel de configuration est un élément de la documentation WinCC. Il est essentiellementconsacré à l'utilisation pratique de WinCC dans les projets.

Introduction

Les exigences auxquelles doivent répondre un système de supervision et de pilotage de process ainsique l'archivage et le traitement informatique des données de production se sont fortement accrues cesdernières années. Pour les satisfaire, de nouveaux systèmes IHM ont été développés par lesconstructeurs.

WinCC est un de ces nouveaux systèmes. En ce qui concerne les fonctionnalités, l'ouverture etl'actualité (état de l'art du logiciel), WinCC est certainement inédit.

Les systèmes IHM de l'ancienne génération ne proposaient souvent qu'une seule manière de résoudreles problèmes posés. WinCC propose presque toujours plusieurs solutions. C'est pour vous permettrede toujours utiliser la meilleure solution au sens des performances et d'un travail de configurationminimum que ce manuel de configuration a été rédigé.

Il présente et propose les solutions permettant d'utiliser WinCC avec un maximum d'efficacité dans lesprojets de commande de process.

Ces propositions, nous les avons réalisées dans des projets-exemples sous WinCC. Ces projets-exemples sont livrés avec le CD-Rom WinCC. Vous pouvez réutiliser ces propositions de solutiondirectement dans vos projets et gagner ainsi un temps précieux.

Manuel de configuration 09.99

1-2 WinCC Configuration ManualC79000-G8277-C157-01

1.1 Manuel de configuration - Remarques sur la structure etl’utilisation du manuel

Prérequis

L'utilisation de ce manuel de configuration suppose que vous ayez déjà acquis une expérience pratiquede WinCC. Pour les nouveaux utilisateurs de WinCC, Getting Started est un composant d'initiationidéal. Getting Started explique les principaux thèmes et présente un exemple pratique destiné àfaciliter la compréhension. Ce manuel de configuration est un complément au système d'aide WinCC(online et documentation papier). Pour les caractéristiques des objets, propriétés et autres thèmes quine sont pas présentés dans le présent manuel, se reporter à la documentation correspondante.

Contenu et structure

La présentation comporte les chapitres suivants.

• WinCC - Remarques généralesCe chapitre contient des remarques générales sur le système WinCC.

• Configuration - Thèmes générauxCe chapitre contient des remarques générales et particulières sur la réalisation structurée et efficacede projets IHM.

• Mise en service des exemplesCe chapitre contient des remarques sur la mise en service des projets-exemples créés dans leprésent manuel.

• Cours de C WinCCChapitre consacré au cours de programmation en WinCC C. Ce module contient les principalesrègles d'emploi du langage de scripts WinCC à l'intention des débutants. Les habitués du C ytrouveront la description des particularités de l'environnement de développement.

• Configuration de variablesCe chapitre présente le projet-exemple Project_TagHandling. Ce projet-exemple expliquel'utilisation en général des variables et des éléments simples d'entrée/sortie (saisie/affichage).

• Configuration de vuesCe chapitre décrit le projet-exemple Prject_CreatePicture. Il expose l'emploi en général des vuesWinCC.

• Editeurs de WinCCCe chapitre présente le projet-exempleProjct_WinCCEditors. Il expose les éditeurs Tag Logging,Alarm Logging et Report Designer.

• User ArchiveCe chapitre décrit le projet-exemple Projct_UserArchive. Il présente l'éditeur User Archive.

• Description des nouvelles fonctionnalitésCe chapitre décrit les fonctionnalités de configuration de systèmes distribués de WinCC proposéespour la première fois par la version 5.

• MulticlientCe chapitre décrit à l'aide de projets-exemples l'emploi du type de projet "Multiclient".

• Serveurs distribuésCe chapitre présente à l'aide de projets-exemples la création d'un projet WinCC distribué entreplusieurs serveurs.

• RedondanceCe chapitre décrit à l'aide d'un projet-exemple la configuration d'une paire de serveurs redondants.

• AnnexeLa quatrième partie est consacrée à divers autres thèmes tirés entre autres des Solutions WinCC etAstuces WinCC.

09.99 Manuel de configuration


Conventions

Le manuel de communication utilise les conventions suivantes:

Convention Description

Clic du bouton gauche de la souris.

GGClic du bouton droit de la souris.

DDouble-clic bouton gauche de la souris.

Italique Désigne des termes de l'environnement WinCC et des termesrenvoyant à des éléments de l'interface de programmation.

Italique vert Désigne une séquence de commandes ou des saisies à effectuer parl'utilisateur comme indiqué dans le manuel (marquage couleuruniquement dans le document online).

Bleu Les renvois sont en bleu (marquage couleur uniquement dans ledocument online).

Recherche d’informations

La version papier du manuel de communication permet la recherche d'informations par les procéduressuivantes.

• Le sommaire contient les informations structurées par thèmes.

• L'index permet la recherche par mots-clé.

Les recherches suivantes sont possibles dans le document online.

• L'onglet Sommaire permet d'accéder aux informations par thèmes.

• L'onglet Index permet la recherche de termes dans un index.

• L'onglet Rechercher permet la recherche de mots dans tout le document.

Vous pouvez également copier les exemples-projets présentés dans ce manuel directement depuis ledocument en ligne sur votre disque dur.

Manuel de configuration 09.99


09.99 WinCC - Remarques générales


2 WinCC - Remarques générales

WinCC - Remarques générales 09.99


2.1 Le concept WinCC

• Il existe dans WinCC toujours trois modes de configuration:

• la configuration avec les outils standard de WinCC;

• la configuration avec utilisation d’applications Windows existantes dans WinCC via les interfacesDDE, OLE, ODBC et ActiveXle développement d'applications propres à l'utilisateur (enVisualC++ ou Visual Basic) intégrées dans WinCC.

Pour les uns, WinCC représente un système IHM de configuration rapide et économique et, pour lesautres, une plate-forme système évolutive à l'infini. La modularité et la souplesse de WinCC offrentdes possibilités totalement nouvelles pour la conception et la réalisation de tâches d'automatisation.

Le système d'exploitation, la base de WinCC

WinCC est architecturé autour du système d'exploitation 32 bits Windows NT 4.0. Ce systèmed'exploitation est le système d'exploitation standard sur plate-forme PC.

La structure modulaire de WinCC

WinCC contient des composants système pour l'affichage, le système d'alarmes, l'acquisition etl'archivage des données de process, ainsi que pour la journalisation et l'intégration coordonnée deroutines utilisateur librement formulées.L'utilisateur a également la possibilité d'intégrer ses propres composants.



2.1.1 Les interfaces de WinCC

L’ouverture de WinCC

WinCC est totalement ouvert à toute extension par l'utilisateur. Cette ouverture absolue est permisepar la structure modulaire de WinCC et par son interface de programmation puissante.La vue ci-dessous montre les possibilités d'intégrer les diverses applications.

Intégration d'applications dans WinCC

WinCC offre la possibilité d'intégrer de manière homogène d'autres applications et modulesapplicatifs à l'interface utilisateur.Comme le montre la figure ci-dessous, WinCC permet d'intégrer à l'application WinCC aussi bien desfenêtres d'application OLE que des contrôles personnalisés OLE (objets OCX 32 bits) et des contrôlesActiveX comme s'il s'agissait d'objets propres à WinCC.



Gestion des données dans WinCC

Dans la figure ci-dessous, WinCC est représenté par toute la partie médiane. Le graphique montre quela base de données standard Sybase SQL Anywhere est subordonnée à WinCC. Elle est utilisée pourenregistrer (avec sécurité transactionnelle) toutes les données de configuration telles que listes devariables et listes d'alarmes, mais aussi les données courantes de process, telles que les alarmes, lesvaleurs de mesure et les enregistrements utilisateur. Cette base de données assume une fonction deserveur. WinCC peut accéder comme client à la base de données via les composants ODBC mais aussipar l'interface de programmation (C-API) ouverte.

Le même droit d'accès est bien entendu accordé à d'autres programmes. Pour cette raison, un tableurWindows ou une base de données Windows peuvent accéder directement aux données contenues dansla base de données WinCC, que l'application tourne sur l'ordinateur local ou sur une station connectéeen réseau. Un langage d'interrogation de base de données SQL et les outils de connectivité associés (p.ex. pilotes ODBC) permettent également à d'autres clients (p. ex. SGBD UNIX tels que Oracle,Informix, Ingres) d'accéder aux données de la base WinCC. L'inverse est bien sûr également vrai. Autotal, rien ne s'oppose à l'intégration de WinCC à un concept de niveau usine ou de niveau entreprise.



2.2 Les termes de WinCC et leur signification

Ce chapitre contient une liste alphabétique de tous les termes relatifs à WinCC. Un grand nombre desnotions expliquées ici vous sont déjà probablement connues:

IHM Interface homme-machine

API Automate programmable industriel

CS Système de configuration

RT Runtime



09.99 Configuration - Thèmes généraux


3 Configuration - Thèmes générauxLe présent chapitre contient de nombreuses remarques et suggestions pour la réalisation de projetsavec WinCC. Un certain nombre de ces remarques ne sont pas spécifiques à WinCC.Idéalement, ces conventions (règles de configuration) auront la qualité d'un guide de configuration etde conception de projets runtime.

Configuration - Thèmes généraux 09.99


3.1 Avant de commencer la configuration

Avant de commencer à configurer, vous devez définir certaines conventions et faire un effort destructuration. Ceci permet:

• de simplifier la configuration;

• d'augmenter la clarté du projet;

• de simplifier le travail en équipe;

• d'améliorer parfois la stabilité et les performances du système et

• de simplifier la maintenance des projets.

La formulation de directives de structuration est une condition indispensable à l'élaboration et àl'amélioration d'un standard d'entreprise.

Ces règles peuvent être classées en deux catégories:

Règles pour la configuration

• Avant de procéder à la configuration, il conviendra d'établir les règles suivantes:

• Définir le nom du projet WinCC

• Définir les noms des variables

• Définir les noms des vues WinCC

• Définir les règles de création des scripts et actions

• Définir les règles de configuration (standards d'entreprise, fonction bibliothèque, travail en équipe)

• Règles concernant la documentation du projet

Règles pour le projet runtime

Il s'agit de règles pour le projet runtime (résultat de la configuration). Ces conventions dépendent dansune large mesure du domaine d'application (industrie automobile, chimie, machine-outil, etc.). Ilconviendra d'établir les conventions suivantes:

• Définir l'interface utilisateur (subdivision de l'écran, type et taille de police, langue du runtime,représentation des objets à l'écran).

• Définir le concept de commande (hiérarchie des vues, philosophie de commande, autorisationsd'accès, boutons autorisés)

• Définir les couleurs des alarmes, valeurs seuils, états, polices, etc.

• Définir les moyens de communication (type de couplage, type et cycle de rafraîchissement)

• Définir les caractéristiques quantitatives (nombre des alarmes, valeurs d'archive, courbes, clients,etc.).

• Définir les procédures d'alarmes et d'archivage



3.2 Conventions

Nous adoptons dans cette partie du manuel des conventions que nous utiliserons dans nos exemples deprojet. Ces règles sont destinées à servir de modèles pour créer vos propres projets.

Remarque:Dans les scripts de nos exemples de projet, les noms des projets, des vues, des variables etles commentaires sont en anglais.

Valeurs par défaut des outils de configuration

Dans la plupart des éditeurs de WinCC, certaines propriétés peuvent être paramétrées par défaut.WinCC supporte ainsi votre propre style de configuration et peut être configuré de manière optimalepour certaines applications.

Remarque:Citons à titre d'exemple les possibilités de Graphics Designer -> Outils -> Paramétrages...Ce sujet est traité de manière exhaustive dans l'aide de Graphics Designer



3.2.1 Convention: Nom de projet WinCC

Généralités

Le nom du projet est également proposé par défaut dans le répertoire dans lequel sont rangées toutesles données d'un projet WinCC. Le nom de répertoire peut être modifié au moment de la création duprojet ou ultérieurement (dans l'explorateur de Windows).

Paramètres / Seuils

Tous les caractères sont permis sauf certains caractères particuliers (p. ex. \ ? ' . ; : / ). Sont égalementautorisées les valeurs numériques 0-9.

Règle

Dans les exemples de projets décrits dans le tome 2 du manuel de configuration, les règles suivantess'appliquent au nom de projet:a...a_nnSignification des lettres:

S Désignation du type (a-z, A-Z, pas de caractères spéciaux).

_n Numéro de série distinguant plusieurs projets d'un même type (chiffres 0-9), plage00-99.

Exemple: cours_00.mcp, ou pictu_01.mcp

Remarque pour l'utilisation généralisée

Le nom de projet WinCC peut par exemple être également utilisé pour distinguer des sous-ensemblesd'un process.

Remarque:Les noms de projet WinCC peuvent être imprimés pour la rétrodocumentation. Ceci facilitela mise en correspondance et la recherche d'informations.



3.2.2 Convention: Noms de variables

Généralités

Les noms des variables à attribuer ne sont plus limités à 8 caractères. Les noms de variable ne doiventcependant pas être trop longs. Le respect de règles fixes pour l'attribution de noms de variablecomporte des avantages très importants pour la configuration.Lors de la création de projets WinCC, la construction de la gestion des variables est une des tâchesclés conditionnant une configuration rapide et efficace et un traitement performant au runtime (dansdes scripts).

Un certain nombre de particularités de la structure de la gestion des variables dans WinCC doiventêtre prises en compte avant de définir les noms de variable. La création de groupes de variables n'ad'effet que sur l'affichage des variables dans la Gestion des variables pendant la configuration. Lesnoms de groupe n'ont aucune influence sur l'unicité des noms de variable. Les noms de variablesdoivent être uniques dans un projet WinCC. L'unicité est vérifiée par le système.WinCC apporte diverses aides pour la sélection des variables, p. ex. pour le tri en colonnes (noms,date, etc.) ou pour l'utilisation de filtres. Il peut cependant être opportun que les noms de variablecontiennent des informations complémentaires.

Convention

Les règles suivantes sont applicables aux noms de variable dans les exemples de projet:xxxy_z...z_a...a_nnSignification des lettres :

x Lettres Type

BIN Variable binaire

U08 Valeur 8 bits non signée (unsigned)

S08 Valeur 8 bits signée (signed)

U16 Valeur 16 bits non signée

S16 Valeur 16 bits signée

U32 Valeur 32 bits non signée

S32 Valeur 32 bits signée

G32 Valeur à virgule flottante 32 bits IEEE 754

G64 Valeur à virgule flottante 64 bits IEEE 754

t08 Variable texte jeu de caractères 8 bits

t16 Variable texte jeu de caractères 16 bits

ROH Type Données brutes

TER Référence texte

STU Types de structures



y Lettres Provenance

r variable de lecture uniquement, lues dans l’API (read)

w variable d'écriture et de lecture, dans l'API (write)

i variable interne de WinCC, sans liaison à l'API

x Variable à adressage indirect (une variable texte dont le contenu est unnom de variable)

_z groupe (correspond à des sous-ensembles ou des bâtiments de production)

_Lack ... p. ex. nom du sous-semble

_a nom de variable (p. ex. nom d'un point de mesure)

_EU0815V10 ... p. ex. désignation du point de mesure

_n Numéro de série de l'instance (chiffres 0-9) plage 00-99.


• L’attribution des noms de variable est soumise aux restrictions suivantes:

• Le caractère spécial @ ne devrait en principe être utilisé que pour les variables système WinCC,mais il est également utilisable d'une manière générale.

• L'utilisation des caractères spéciaux ' et % est interdite.

• Le caractère spécial " et la séquence de caractères // (réservés) ne doivent pas être utilisés car ilsont une signification spéciale dans les scripts en C (introduction ou terminaison d'une séquence decaractères et introduction d'un commentaire).

• Pas de blancs

• Le système ne discrimine pas les minuscules des majuscules dans les noms de variable.


Les noms attribués aux variables dans les exemples ne sont que des propositions.Lorsqu'on utilise les variables dans des scripts et dans Excel, il peut être judicieux d'attribuer unelongueur fixe (si nécessaire avec caractères de remplissage , 0 ou x) aux éléments du nom de lavariable.Excel permet p. ex. de créer / d'assurer la maintenance - avec facilité et efficacité - de grandesquantités de variables. Le respect d'une structure fixe dans la constitution du nom de variable facilitela création des listes de variables dans Excel. Ces listes de variables créées dans Excel peuvent êtreimportées avec le programme \SmartTools\CC_VariablenImportExport\Var_exim.exe, qui se trouvesur votre CD WinCC CD, dans le projet courant WinCC.



3.2.3 Convention: Noms de vues

Généralités

Lorsque des vues doivent être appelées dans des scripts ou dans des programmes externes, il peuts'avérer très utile de respecter une structure fixe pour l'attribution des noms de vue. Il est bon de bienréfléchir à la longueur des noms de vue. Les noms trop longs (noms de fichier) ont plutôt tendance àaffecter la clarté (sélection dans des zones combo, appel dans des scripts, etc.). La pratique a montréqu'une longueur maximale de 40 caractères était idéale.


• L’attribution des noms de vue est soumise aux restrictions suivantes:

• Longueur maximale de 255 caractères.

• Caractères quelconques sauf les caractères spéciaux (p. ex. / " \ : ? :

• Le système ne discrimine pas les majuscules des minuscules.

Convention

Les règles suivantes sont applicables aux noms de vue dans les projets de ce manuel:aaaaa_k_x...x_nnSignification des lettres:

S Lettre code (a-z, A-Z, pas de caractères spéciaux) pour les groupes de vues.

cours... p. ex. nom des vues du cours de C

_k Code du type de vue 0 à 99 Type de vue

_0 Vue de démarrage

_1 Vue synoptique

_2 Vue de boutons

_3 Vue de process

_4 Vue de détail

_5 Vue d'alarmes

_6 Vue de courbes

_7 ...

_8 ...

_9 Vues de diagnostic (uniquement pour tests et mise enservice)

_x Nom décrivant la fonction de la vue (a-z, A-Z, pas de caractères spéciaux), 30caractères au maximum.

_chapter ... p. ex. noms des chapitres du cours de C

_n Numéro de série de type de vues (chiffres 0-9) plage 0-99.




Les noms attribués aux vues dans les exemples ne sont que des propositions. Le respect de la règleque nous avons adoptée est cependant la condition de l'utilisation d'une partie des scripts fournis avecle produit.



3.2.4 Convention: Scripts et actions

Généralités

L'utilisateur peut créer ses propres scripts et actions dans les projets WinCC. Choisissez des nomssignificatifs. Ceci s'avérera très utile lorsque vous utiliserez vos scripts.Pour la configuration dans Global Script (éditeur), l'utilisation d'un type de police proportionnel nefavorise par la lecture. Pour une meilleure lisibilité, il est recommandé d'utiliser une police ayant unelargeur de caractère constante (p. ex. Courier).Les scripts doivent toujours comporter des commentaires suffisants pour permettre la compréhension.Le temps passé à créer des commentaires est sans rapport avec celui que l'on peut perdre en essayantde comprendre ultérieurement un programme mal commenté. Bien que suffisamment connu, ceci estsouvent ignoré.

Règles

Les règles suivantes sont applicables aux scripts utilisés dans les projets de ce manuel:Nous utilisons la police proportionnelle Courier New, taille 8.Tous les noms de variables et commentaires sont en anglais.


Une description détaillée de l'utilisation des scripts, actions et éditeurs est donnée au chapitreEnvironnement de développement de scripts C.



3.2.5 Convention: L’interface utilisateur

Généralités

Il est très important de créer l'interface utilisateur avec grand soin. Tous les objets créés dans GraphicsDesigner sont affichés à l'écran dans l'espace de travail de l'utilisateur.Les vues ainsi créées sont la seule interface entre l'homme et la machine et nécessitent par conséquentbeaucoup de soin dans la mesure où elles conditionnent en grande partie la réussite d'un projet. Bienentendu, le fonctionnement du système est plus important que l'aspect de l'écran; mais à long terme,des vues à la conception négligée peuvent égratigner l'image donnée par un système par ailleurs bienpensé et augmenter les coûts de maintenance.Ce sont les vues que l'utilisateur (le client) voit tous les jours.Un système d'écrans n'a pour seule finalité que de fournir à l'utilisateur des informations sur l'étatcourant du process à l'aide des vues. L'interface doit par conséquent fournir des informations aussiexhaustives et aussi claires que possible.WinCC vous permet de configurer librement l'interface utilisateur. Votre configuration dépend dumatériel utilisé, des contraintes du process et des conventions existantes.

L'opérateur

Vous devez, pour définir l'interface utilisateur, placer l'opérateur, à qui la configuration est en fin decompte destinée, au centre de vos réflexions.Si vous parvenez à mettre les informations nécessaires à la disposition de l'opérateur et à les afficherd'une manière claire, ceci se traduira par une meilleure qualité de la production et moinsd'interruptions de l'exploitation . Les travaux de maintenance s'en trouveront réduits.L'opérateur a besoin d'autant d'informations que possible. Celles-ci lui permettent de prendre lesdécisions nécessaires pour conduire le process de manière optimale. L'opérateur ne doit pas seulementréagir aux alarmes (dans ce cas, le process est déjà perturbé), mais aussi pouvoir anticiper l'évolutiondu process, à l'aide de son expérience, de sa connaissance du process et des informations fournies parle système de conduite. L'opérateur doit pouvoir prendre des mesures contre une défaillance avant quecelle-ci survienne. WinCC vous donne la possibilité de préparer et d'afficher efficacement cesinformations à l'opérateur.

Combien d’informations doit contenir une vue ?

Savoir combien d'informations doivent être contenues dans une vue dépend de deux aspects d'égaleimportance:

• Une vue contenant trop d'informations est difficilement lisible et la recherche d'informations ydemande trop de temps. La probabilité de survenance d'une erreur de conduite augmente.

• Une vue contenant trop peu d'informations augmente la charge de travail de l'opérateur. Il perdalors la vision d'ensemble du process et doit changer fréquemment de vue pour trouverl'information nécessaire. Des réactions, des commandes entrées tardivement et l'instabilité duprocess en sont les conséquences.

Des études montrent qu'un opérateur expérimenté souhaite trouver dans chaque vue autantd’informations que possible afin de ne pas devoir changer constamment de vue.Un débutant par contre est dérouté lorsqu'une vue contient trop d'informations. Il ne trouve pas ou troptard la bonne information.Mais nous savons une chose par expérience: un débutant deviendra vite un opérateur expérimentéalors qu'une personne expérimentée ne redeviendra jamais un novice.



Masquage d’informations

Les informations à afficher doivent être pertinentes et faciles à comprendre. Vous pouvez masquercertaines informations (p. ex. code de point de mesure) jusqu'à ce que leur affichage deviennenécessaire.

Affichage des informations

Il est recommandé pour l'affichage de valeurs analogiques de combiner des instruments à index à desvaleurs numériques. La visualisation graphique (instruments à index, bargraphes, etc.) est mieuxadaptée à la perception visuelle de l'information.Afin de prévenir d'éventuelles difficultés à reconnaître les couleurs (daltonie), les modificationsimportantes d'un objet (état) doivent être signalées à la fois par un changement de couleur et par unchangement de forme.Certaines informations doivent sauter aux yeux dans une vue. Ceci suppose l'emploi ciblé decontrastes.

Code couleurs

L'oeil perçoit plus rapidement les couleurs que p. ex. le texte. L'utilisation d'un code de couleurspermet de percevoir plus rapidement l'état dans lequel se trouvent les différents objets. Il est importantde toujours bien respecter le code de couleurs choisi. Des conventions de couleurs homogènes pourreprésenter les états dans un projet (p. ex. rouge pour les défaillances) sont maintenant un standard.Les standards d'entreprise existant chez le client doivent être pris en compte.

Affichage de textes

Un certain nombre de règles simples doivent être observées pour améliorer la visibilité du texte.

• La taille du texte doit être adaptée à l'importance de l'information communiquée mais aussi à ladistance probable qui séparera l'opérateur de l'écran.

• Utilisez de préférence les minuscules. Elles prennent moins de place et se lisent mieux que lesmajuscules, bien que ces dernières soient plus facile à reconnaître de loin.

• Un texte horizontal est plus facile à lire qu'un texte vertical ou incliné.

• Utilisez des polices différentes pour des informations différentes (p. ex. pour les noms de point demesure, notas, etc.).

Pas d’entorse au concept

Quel que soit le concept pour lequel vous vous être décidé, vous devez vous y tenir dans tout le projet.Vous contribuez ainsi à la possibilité de commander intuitivement les vues de process. Les erreurs deconduite deviennent plus improbables.Ceci est également le cas pour les objets utilisés. Un moteur ou une pompe doit toujours êtrereprésenté de la même façon quelle que soit la vue dans laquelle ces objets sont utilisés.

Division de l'écran

Lorsque des écrans de PC standard sont utilisés dans le process, une division de l'écran en trois zones(zone supérieure/synoptique, zone de travail et zone de boutons) s'est avérée judicieuse.Cette division de l'écran n'est cependant pas toujours opportune lorsque votre application tourne surun PC industriel spécifique ou sur un terminal opérateur (OP).



Les vues occupent la totalité de l'écran

L'écran est divisé en trois zones:zone supérieure, zone de boutons et zone de vues deprocess



Exemple de terminal opérateur


Vous pouvez choisir librement la taille des vues entre des limites fixes (mini 1 x 1, max. 4096 x 4096pixels). Sur les systèmes monoposte équipés d'un moniteur 17" il est recommandé de travailler avecune résolution maximale de 1024 x 768 pixels. Sur les systèmes multiposte (Multi-VGA), unerésolution plus élevée peut se justifier.Sur les terminaux opérateur, la technologie existante limite généralement la résolution (TFT de 640 x480 à 1024 x 768).

Règles

Les règles suivantes sont applicables aux vues utilisées dans les projets de ce manuel:

Résolution

Nous utilisons dans nos projets une résolution de 1024 x 768 et, dans certains cas exceptionnels, de800 x 600 pixels. Nous considérons que la palette de couleurs de votre PC doit être paramétrée sur65536 couleurs au minimum pour garantir une visualisation correcte de nos exemples de projet.

Textes

Nous utilisons pour les désignations de points de mesure la police Courier, pour les textes purementdescriptifs et pour tous les autres textes et affichages de texte la police Arial. Les polices MS SansSerif et System sont utilisées pour les boîtes de message de type Windows.Nous adaptons la taille de police en fonction des nécessités.



Informations dans les vues

Chaque fois que cela paraît souhaitable, nous masquons des informations dans les vues. Nous nemontrons ces informations masquées qu'en cas de besoin (par conduite opérateur ou pardéclenchement automatique).Nous utilisons dans nos projets plusieurs divisions d'écran. Pour de nombreux objets commandés paropérateur, nous formulons des consignes de conduite par des étiquettes.

Division de l'écran

Nous configurerons les possibilités de division de l'écran qui existent en principe. Dans les autresprojets, vous utiliserez cependant la division en ligne de titre, zone de travail et zone de boutons.


Vous pouvez réutiliser directement dans vos projets la division de base de l'écran.



3.2.6 Convention: Le concept de commande

Généralités

Vous disposez pour la conduite de votre application de process des moyens de saisie connus tels queclavier, souris, écran tactile, joystick industriel. Dans les environnements industriels sévères, danslesquels l'utilisation d'une souris n'est pas possible, vous pouvez utiliser la commande par pointeur etcurseur. Le pointeur saute pour se placer sur les champs de commande, le curseur sur les champs desaisie.Toutes les commandes peuvent être protégées contre les accès non autorisés.

Sélection de vue

Le concept de sélection des vues dépend de plusieurs facteurs. L'élément décisif est le nombre de vueset la structure du process à représenter.Pour les petites applications, les vues peuvent être organisées en tampon cyclique.

Lorsque le nombre des vues est important, un agencement hiérarchique est indispensable à la sélectionde vues. Il convient de choisir une structure invariable et simple pour faciliter au personnel deconduite l'apprentissage de la sélection des vues.La sélection directe de vues est naturellement aussi possible et éventuellement avantageuse pour lestrès petites applications (p. ex. chambre frigorifique).

Hiérarchie

Une structure hiérarchisée rend le process plus clair, plus facile à gérer et permet, si nécessaire,d'accéder rapidement à des informations détaillées.Une hiérarchie à trois niveaux est fréquemment utilisée.

Niveau 1

Le niveau 1 contient les vues synoptiques.Ce niveau contient essentiellement des informations sur les sous-systèmes du process et montre lesinteractions entre ces sous-systèmes.Ce niveau indique aussi si un événement est survenu à des niveaux inférieurs (alarme).

Niveau 2

Le niveau 2 contient les vues de process.Ce niveau contient des informations détaillées sur un sous-système du process et montre les objets deprocess appartenant à ce sous-ensemble.Ce niveau affiche également l'objet du process qui est concerné par une alarme.



Niveau 3

Dans le niveau 3 sont rangées les vues de détail.Ce niveau fournit des informations sur des objets de process, p. ex. régulateurs, vannes, moteurs, etc..Ce niveau affiche les alarmes, états et valeurs de process. Il fournit également des informations surl'interaction avec d'autres objets de process.

Convention

La convention suivante sera valable pour tous les projets créés dans le présent manuel:Nous utiliserons dans nos projets plusieurs concepts de commande et montrerons leurs différences.


Nos projets ne peuvent être considérés que comme des suggestions pour l'élaboration d'un concept deconduite propre à l'utilisateur. En cas d'extension des installations du process, il convient de tenircompte des concepts de conduite existants. Il existe à présent chez de nombreux utilisateurs desstandards d'entreprise qu'il convient de prendre en compte dans la configuration.

Remarque:Un concept de commande prêt à l'emploi est disponible dans l'option WinCC Basic ProcessControl. Ce package optionnel contient en outre d'autres fonctions utiles et performantes (p.ex. Storage).



3.2.7 Convention: Le paramétrage des couleurs

Généralités

L'utilisation des couleurs dans les systèmes IHM fait l'objet de vives discussions. WinCC permet dechoisir librement les couleurs des traits, bordures, arrière-plans, motifs de remplissage et polices.Toutes les couleurs supportées par Windows sont disponibles. Bien entendu, WinCC permetégalement de modifier les couleurs et naturellement aussi les autres propriétés des graphiques auruntime.Une importance particulière revient à la définition des couleurs lorsqu'il s'agit d'obtenir unevisualisation claire des process par une configuration économique.

• Des couleurs devront toujours être définies pour les domaines ci-dessous. Les couleurs peuventéventuellement être définies selon DIN EN 60073 (correspond à VDE 0199). Elles doiventcependant toujours être arrêtées en concertation avec l'utilisateur:

• Couleurs pour les alarmes (arrivées / parties / acquittées)

• Couleurs des états (marche / arrêt / défaut)

• Couleurs des objets de dessin (canalisations / niveau de remplissage)

• Couleurs des seuils d'avertissement et seuils d'alarme

Conventions

Les règles suivantes sont applicables à toutes les couleurs utilisées dans les projets de ce manuel:La représentation correcte des projets servant d'exemples suppose que vous ayez choisi unparamétrage de plus de 256 couleurs.Pour une plus grande clarté, nous utilisons dans les projets exemples une couleur d'arrière-plandifférente pour les divers thèmes (variables, cours de C, configuration de vues). La couleur de fond estplus foncée dans la zone supérieure et dans la zone de boutons.Dans le système d'alarmes, un code couleur particulier est affecté à chaque classe d'alarmes et àchaque type d'alarme d'une classe d'alarmes.


Vous devez, le cas échéant, modifier le paramétrage par défaut de WinCC après avoir défini lescouleurs.Vous trouverez un tableau des couleurs utilisées dans les actions C à l'annexe du chapitre Tableau decouleurs.



3.2.8 Convention: Les cycles de rafraîchissement

Généralités

Lors de la définition du rafraîchissement des données, il est toujours décisif de prendre en comptel'ensemble du système. Que faut-il rafraîchir et selon quels cycles? Un mauvais choix des cycles derafraîchissement peut avoir des répercussions négatives sur les performances du système IHM.Il convient en considérant un système global (API - Communication - IHM) de détecter lesmodifications là où elles apparaissent, c'est-à-dire dans le process (API). Dans de nombreux cas, lebus constitue le goulot d'étranglement pour la transmission des données.Pour définir la périodicité du rafraîchissement des valeurs de mesure, observez à quelle cadence lavaleur de mesure est réellement modifiée. Un temps de cycle de rafraîchissement de 500 ms n'auraitaucun sens pour la régulation de température d'une chaudière de 5000 l.

Système IHM 32 bits

WinCC est un système IHM exclusivement 32 bits architecturé autour de Windows NT. Ces systèmesd'exploitation sont optimisés pour la commande événementielle. Si vous respectez ce principe pour laconfiguration avec WinCC, les problèmes de performances seront plutôt l'exception même si lesvolumes de données à gérer sont très élevés.

Conventions

Les règles suivantes sont applicables pour le rafraîchissement dans les projets du présent manuel:Le rafraîchissement est effectué si possible par commande événementielle si la tâche d'automatisationle permet. Comme nous travaillons essentiellement avec des valeurs de variables internes, nousutilisons souvent les modifications de variables comme déclencheurs du rafraîchissement. Lorsque desvariables externes sont utilisées, ceci peut entraîner une charge plus importante pour le système. Si lacommunication permet une transmission à déclenchement événementiel, choisir cette option pour lesdonnées à temps critique. Les données non critiques peuvent alors être appelées par l'IHM selon uncycle approprié (procédure d'invitation à émettre).


Une description détaillée de l'utilisation des cycles de rafraîchissement est donnée au chapitre Cyclesde rafraîchissement - Où et comment paramétrer.



3.2.9 Convention: Les autorisations d'accès

Généralités

Il est nécessaire en exploitation de process que certaines fonctions de conduite soient protégées contreles accès non autorisés. Il convient en outre de réserver à certaines personnes l'accès au système deconfiguration.Les utilisateurs et groupes d'utilisateurs peuvent être créés et divers niveaux d'autorisation sont définisdans User Administrator. Ces niveaux d'autorisation peuvent être liés aux éléments de commandedans les vues.Divers niveaux d'autorisation peuvent être affectés individuellement aux utilisateurs et groupesd'utilisateurs.

Règle

Tous les utilisateurs ont l'autorisation d'accès aux commandes dans les exemples de projet Project_C-Course et Project_TagHandling.Dans l'exemple de projet Project_CreatePicture , la commande n'est possible dans le projet qu'aprèsconnexion au système (login). Le mot de passe correspond au nom du projet ( Project_CreatePicture).Les boutons de sélection des différents thèmes sont liés au niveau d'autorisation Conduite de projet.

Remarque sur l'utilisation généralisée

Une description de l'attribution des autorisations est donnée dans le Manuel de configuration, Partie 2,dans le projet exemple Project_CreatePicture, chapitre Autorisations de conduite.



3.2.10 Convention: Les procédures d'alarme

Généralités

• WinCC supporte deux procédures d'alarmes:

• La méthode des alarmes déclenchées par changement d'état d'un bit est une procédure universellepermettant le déclenchement d'alarmes par des automates quelconques. WinCC surveille leschangements de front de variables binaires sélectionnées et les utilise comme événements dedéclenchement d'alarmes.

Les alarmes déclenchées chronologiquement supposent que les automates génèrent eux-mêmes lesalarmes et les transmettent à WinCC dans un format prédéfini avec leur horodatage, éventuellementavec des valeurs de process. Ce système d'alarmes permet le classement par ordre chronologiqued'alarmes en provenance des divers automates. Voir chapitre Documentation du système d'alarmesS5.

Que faut-il signaler?Pour convenir des événements et des états à signaler dans les alarmes, on adopte souvent la méthodeconsidérée comme sûre qui consiste à signaler tous les événements et tous les changements d'états.C'est alors à l'opérateur de décider des alarmes qu'il veut consulter en premier.Lorsque trop d'événements sont signalés par un système d'automatisation, l'expérience montre qu'ilarrive souvent que des alarmes importantes soient prises en compte trop tard.

Remarque sur l'utilisation généralisée

L'affichage et la sélection des alarmes pour l'archivage peuvent être modifiés et adaptés aux exigencesde l'utilisateur.



3.2.11 Convention: Réalisation

Généralités

Au niveau de la réalisation d'un projet, il est opportun d'utiliser une structure fixe pour enregistrer lesdonnées. Le choix du lecteur sur lequel sera enregistré le projet WinCC est la première étape. L'étapesuivante concerne la structure de répertoire, etc.Notre expérience montre qu'il est conseillé de ranger toutes les données d'un projet dans un répertoireet ses sous-répertoires. Cette démarche présente des avantages pour la réalisation du projet mais avanttout pour la sauvegarde des données.

Remarque:La configuration matérielle et logicielle des PC est très variable. Afin de libérer l'utilisateurde telles contraintes pour l'attribution du lecteur cible au projet, on pourra utiliser deslecteurs virtuels. L'affectation du répertoire au lecteur virtuel peut être modifiée à toutmoment.

Définition des répertoires

Outre les répertoires créés par WinCC, vous devrez créer selon les besoins d'autres répertoires pourWord, Excel et pour les fichiers temporaires.



3.3 Particularits de la configuration avec WinCC

Les prochains chapitres traitent des thèmes généraux de la configuration avec WinCC.Ces thèmes constituent un complément à l'aide WinCC.



3.3.1 Cycles de rafrachissement - O et comment paramtrer ?

La définition des cycles de rafraîchissement est l'un des paramétrages les plus importants du systèmede visualisation. Le paramétrage influe sur les propriétés suivantes:

• la formation de la vue

• le rafraîchissement des objets de la vue ouverte sur la station de visualisation (Graphics Designer)

• L'édition de scripts d'arrière-plan (Global Script)

• L'activation du gestionnaire des données et de la communication processD'autres paramètres temporels se règlent dans le module de traitement de valeurs de mesure (TagLogging) à l'endroit concernant les temps d'archivage.

Gestionnaire de données

Les valeurs courantes des variables sont appelées par le gestionnaire de données, l'instance centrale dela gestion des variables, en fonction des cycles de rafraîchissement paramétrés. Siehe Kapitel WinCCDynamisierung.Le gestionnaire de données constate les nouvelles données de process via les canaux decommunication et fournit ces valeurs courantes aux applications. La requête de données implique ainsitoujours un basculement entre diverses tâches (Graphics Designer, Gestionnaire de données, etc.).Ceci peut entraîner une charge très variable du système en fonction de la configuration.



3.3.1.1 Le rafraîchissement des vues

Rafraîchissement d'une vue

Le rafraîchissement des propriétés des objets dynamisés dans une vue s'effectue après l'affichage de lavue. Le cycle de rafraîchissement choisi détermine l'actualité des propriétés affichées pour chaqueobjet dans une vue. Le cycle de rafraîchissement des objets dynamisés peut être paramétré, par letechnicien chargé de la configuration ou par le système, pour les modes de dynamisation suivants:

Type de dynamisation Paramétrage par défaut Adaption de laconfiguration

Dialogue deconfiguration

Déclencheur activé par variable2 s.Ou déclencheur activé parévénement (p. ex. action decommande)

Adaptation des cyclestemporels

Dynamic-Wizard Le déclencheur sélectionné peutêtre, en fonction du type dedynamisation, un

• Déclencheur événementiel

• Cycle

• déclencheur activé par unevariable.

Adaptation des cyclestemporels, événements ouvariables

Liaison directe Evénement déclencheur

Liaison de variable Déclencheur activé par variable2 s.

Adaptation des cyclestemporels

Dialogue dedynamisation

Déclencheur activé par variable2 s.

Adaptation des cycles,déclencheurs activés parvaleur de variable

Action C pour propriétés Cycle 2 s Adaptation des cycles,déclencheurs activés parvaleur de variable

Lecture directe dans API

Propriétés d'objet Paramétrage en fonction de ladynamisation

Edition de la colonne Cyclede rafraîchissement



Les cycles de rafraîchissement disponibles pour la sélection sont proposés par WinCC et peuvent êtrecomplétés par des cycles définis par l'utilisateur.

Sélection des cycles de rafraîchissement, p. ex. pour la propriété d'un objet:

3.3.1.2 Types de cycles de rafraîchissement

On distingue les types de cycles de rafraîchissement suivants:

Type Paramétrage par défaut

Cycle par défaut Cycle 2 secondes

Cycle 2 secondes

Déclencheur activé par variable 2 secondes

Cycle de vue 2 secondes

Cycle de fenêtre Sur modification de valeur de variable

Cycles définis par l'utilisateur Cycle utilisateur 1:2 s

Cycle utilisateur2:3 s




Cycle utilisateur



Il est possible de définir jusqu'à 5 cycles utilisateur spécifiques à un projet. Si, dans WinCCExplorer, le nom de projet est sélectionné dans l'arborescence de gauche, vous pouvez ouvrir avec lebouton représenté ci-dessous de la barre d'outils le dialogue Propriétés - Projet.

Le dialogue Propriétés de projet, onglet Cycles de rafraîchissement, propose, à la fin de la liste descycles de rafraîchissement par défaut paramétrés, les cycles utilisateur 1...5 pour la définition de cyclespécifique au projet. Seuls ces cycles utilisateur peuvent être paramétrés.

Ceci permet de définir des temps de cycle pas encore disponibles comme cycles de rafraîchissement(p. ex. 200 ms).Le temps de cycle utilisateur peut être défini entre 100 ms et 10 h. La désignation des cyclesutilisateur peut être choisie librement.Ces cycles spécifiques à un projet peuvent être utilisés pour des objets sélectionnés dont le cycle derafraîchissement doit être modifié ultérieurement. Une optimisation pourrait être, par exemple, unmotif de modification des temps de cycle. Les cycles de rafraîchissement définis par l'utilisateurpermettent de modifier ultérieurement le cycle paramétré en un seul endroit. Il n'est alors plusnécessaire d'adapter les divers objets des vues. Cette méthode de définition des temps de cycleutilisateur est donc à prendre en considération en vue de configurer des projets à grande facilité demaintenance.



3.3.1.3 Signification des cycles de rafraîchissement

Avant d'utiliser les différents cycles de rafraîchissement possibles, il convient d'en examiner toutd'abord la signification.On distingue les types de cycles de rafraîchissement suivants:

Type Signification

Cycle standard Cycle temporel

Cycle temporel La propriété ou l'action de l'objet est rafraîchie selon le cycleparamétré. Cela signifie que les variables sont demandéesindividuellement à chaque requête par le gestionnaire de données.

Déclencheuractivé parvariable

Le contenu des variables est lu par le système, qui vérifie si leur valeura été modifiée dans le temps de cycle paramétré.

Toute modification d'au moins une variable sélectionnée, dans le cycleparamétré, déclenche les propriétés ou actions dépendant de cedéclencheur.

Toutes les valeurs de variable sont demandées ensemble par legestionnaire de données.

Cycle de vue Rafraîchissement des propriétés de l'objet de vue courant et de tous lesobjets déclenchés par le déclencheur de rafraîchissement 'Cycle devue'.

Cycle de fenêtre Rafraîchissement des propriétés de l'objet Fenêtre et de tous les objetsayant comme cycle de rafraîchissement le cycle de fenêtre.

Cycles définis parl'utilisateur

Cycles pouvant être définis de manière spécifique à un projet.

Action C pourlecture directedans API.

Des fonctions internes contenues dans les actions C permettent de liredirectement des valeurs dans les API. L'exécution des instructions del'action C qui suivent n'est reprise qu'après la lecture des valeurs deprocess (lecture synchrone).

Remarque:La requête par le gestionnaire de données de communication de la valeur réelle couranted'une variable entraîne toujours un basculement de tâche et un échange de données entre lestâches. Le gestionnaire doit en outre émettre une requête de communication des valeurs devariables par le canal de communication des automates connectés. Ceci est réalisé enfonction du type de communication par des télégrammes de requête envoyés à l'interface decommunication (FETCH) et des télégrammes de données émis en retour par l'automate àWinCC.

3.3.1.4 Remarques sur l'utilisation des cycles de rafraîchissement

Le paramétrage suivant est recommandé pour l'utilisation des cycles de rafraîchissement en fonctiondu mode de rafraîchissement utilisé:

Type Paramétrage pardéfaut

Recommandation pour la configuration

Cyclestandard

Cycle 2 secondes Dialogue de dynamisation ou action C:

Utilisez impérativement un déclencheur activé parvariable lorsqu'il existe dans le process une relation dedépendance par rapport à des variables. Ceci permet deréduire le nombre des changements de tâche et le volumedes données échangée lors de la communication entre lestâches.



Type Paramétrage pardéfaut

Recommandation pour la configuration

Le déclenchement par modification de variable ne doitêtre utilisé que très sélectivement car il entraîne unecharge plus lourde pour le système ! Dans ce cas, lesystème vérifie constamment s'il y a eu modification de lavaleur d'une variable. Ce système d'invitation àtransmettre augmente toujours la charge du système.

Pour des objets standard, il est recommandé d'utiliser uncycle de 1 à 2 secondes.

Cycletemporel

2 secondes Choisissez toujours le cycle en fonction du type d'objet oude la propriété de l'objet. Tenez compte de l'inertie descomposants du process (remplissage de cuves outempératures, à la différence des manoeuvres decommutation).

Pour des objets standard, il est recommandé d'utiliser uncycle de 1 à 2 secondes.

Déclencheuractivéparvariable

2 secondes

(dialogue dedynamisation)

Utilisez de préférence ce mode de rafraîchissementlorsqu'il est configurable (fonction du mode dedynamisation) ! S'il existe une relation de dépendance parrapport à des variables, prendre impérativement en comptetoutes les variables responsables d'une modification de lapropriété ou de l'exécution de l'action. Seules les variablesfigurant dans la liste peuvent servir de déclencheur pourrafraîchir la propriété ou l'option dynamisée.

N'employez le déclenchement par modification de valeurde variable que dans des cas bien précis. Le déclencheurde cette propriété ou action sera activé dès que la valeurd'une des variables sélectionnée sera modifiée. Cemécanisme d'invitation à transmettre entraîne une plusgrande charge pour le système.

Cycle devue

2 secondes Ne choisissez un cycle plus court que si les propriétés del'objet "vue" dynamisées sont elles-mêmes modifiées dansune période plus courte et doivent par conséquent êtrerafraîchies. L'augmentation de la période de ce cycle devue réduit la charge du système.

Cycle defenêtre

Sur modification Ce paramétrage est approprié lorsqu'il s'agit d'une fenêtrede vue affichée p. ex. pour la modification de grandeursde process (boîte d'info de process).

Paramétrez le rafraîchissement de la fenêtre et de soncontenu par un déclencheur activé par variable ou selon uncycle si la fenêtre de la vue est affichée constamment pourinformation (p. ex. organisation de l'écran).

Action Cpourlecturedirectedans API

Les fonctions internes (p. ex. GetTagWordWait ) servant àla lecture synchrone de valeurs de process (directementdans l'API) doivent être utilisées très sélectivement.L'emploi de ces fonctions nécessite une invitation àtransmettre par le système (pilotage d'action) qui entraîneune charge de communication plus élevée.

Les exemples ci-dessous montrent où paramétrer les cycles de rafraîchissement:



Dialogue de configuration

Ce dialogue est affiché lors de la configuration d'un objet complexe

Champ E/S. Vous pouvez également l'appeler d'un clic D sur l'objet correspondant .



Dynamic Wizard

Cette page est affichée à la sélection de la commande Dynamiser Propriétés, onglet Dynamisations

standard dans Dynamic-Wizard avec GG.



Liaison à des variables pour une propriété d'objet

Ce menu est affiché à la sélection de la colonne Rafr. avec D pour une propriété d'objet dynamiséepar une variable.



Dialogue de dynamisation

Dans les dialogues de dynamisation, les dialogues sont appelés par sélection du bouton qui déclenchel'affichage du dialogue de modification du cycle de rafraîchissement.

Action C pour propriété

Pour une action C, le dialogue de modification du cycle de rafraîchissement s'appelle par sélection dubouton de déclencheur dans l'éditeur.



Les cycles de rafraîchissement paramétrés par défaut peuvent être modifiés de la manière suivante:

Cycle de vue

Modification du cycle de vues

Cycle de fenêtre

Modification du cycle de fenêtre



3.3.1.5 Exécution de scripts en arrière-plan (Global Script)

L'exécution de scripts en arrière-plan (Global Script) dépend de plusieurs grandeurs qui sont fonctionde la configuration effectuée:

• Déclencheur temporel (exécution cyclique, exception: acyclique = une seule fois)

• Cycle temporel

• Instant

• déclencheur activé par événement

ou une seule fois



Cycle temporel

Le cycle configuré pour l'action globale détermine quand les instructions constituant l'action doiventêtre exécutées. Outre le cycle standard déjà décrit et les paramétrages de cycle correspondants (de 250ms à 1 h) (ou cycle utilisateur 1 à 5), il est également possible de sélectionner des déclencheurstemporels:

• Heure (minute et seconde)

• Jour (heure, minute, seconde)

• Semaine (jour, heure, minute, seconde)

• Mois (jour, heure, minute, seconde)

• Année (mois, jour, heure, minute, seconde)



Déclencheur activé par variable

Le déclencheur événementiel doit être paramétré comme déclencheur activé par variable si l'action estactivée par la valeur d'une ou de plusieurs variables. Ceci s'effectue de manière analogue à l'activationde déclencheur par variable pour les propriétés d'objets.

Le cycle paramétré par défaut est 2 secondes. Le technicien chargé de la configuration peut paramétrerles cycles ci-dessous à la place de la valeur par défaut:



La valeur de la variable sélectionnée est lue au début et à la fin de chaque cycle paramétré. Ledéclencheur est activé pour l'action globale lorsque la valeur d'une variable au moins a été modifiée.N'oubliez pas que le déclenchement par modification de valeur de variable augmenteconsidérablement la charge du système. Ce paramétrage n'est pas toujours opportun. Les remarquesfaites pour le rafraîchissement d'objets sont également valables ici.Toutes les actions que vous avez définies comme actions globales ne sont pas testées et activéesspécifiquement à l'objet, mais uniquement selon les cycles paramétrés ou par des déclencheursévénementiels. Utilisez par conséquent les actions globales de manière très sélective et évitez lesinstructions superflues dans les actions afin de ne pas surcharger inutilement le système. N'utilisez pastrop de cycles ni trop de cycles courts pour l'exécution des actions.



3.3.2 Dynamisation WinCC

Définition

Nous entendons par dynamisation le changement d'états (p. ex. position, couleur, police, etc.) et laréaction à des événements au runtime (p. ex. clic de souris, commandes clavier, modification devaleurs, etc.).

Chaque élément d'une fenêtre est considéré comme un objet autonome. La fenêtre est elle-même unobjet du type Objet vue.Dans le système graphique WinCC, chaque objet possède des propriétés et des événements. Aquelques rares exceptions près, ceux-ci peuvent être dynamisés. Ces exceptions concernent pourl'essentiel les propriétés et événements qui nont pas d'effet au runtime. Ils ne possèdent pas desymbole de propriété ou d'événement dynamisable.

3.3.2.1 Dynamisation des propriétés

Les propriétés d'un objet (position, couleur, police, etc.) peuvent être activées statiquement etmodifiées dynamiquement au runtime.Toutes les propriétés marquées d'une ampoule dans la colonne Dynamisation sont dynamisables.Lorsqu'une propriété est dynamisée, un symbole de couleur est affiché à la place de l'ampoule blancheen fonction du type de dynamisation. Les propriétés (p. ex. géométrie) dynamisées sont affichées engras.



3.3.2.2 Dynamisation des événements

Les événements d'un objet (p. ex. clic de souris, commandes clavier, modification de valeurs, etc.)peuvent être testés au runtime et exploités dynamiquement.Tous les événements marqués d'une flèche dans la colonne Action sont dynamisables. Lorsqu'unévénement est dynamisé, une flèche de couleur est affichée à la place de la flèche blanche en fonctiondu mode de dynamisation. Les propriétés (p. ex. Autres) dynamisées sont affichées en gras.

3.3.2.3 Types de dynamisation des objets

Les objets d'une vue de process peuvent être dynamisés de diverses manières. Les divers dialoguesstandard de dynamisation sont conçus pour des domaines d'application différents et conduisent enpartie aussi des résultats différents.

Vue d’ensemble

Type dedynamisation

S B Avantage Inconvénient

DynamicWizard

x x Démarche guidéestandard pour laconfiguration

Uniquement pour certainesdynamisations. Génère toujoursune Action en C!

Liaison directe x Le type de dynamisationle plus rapide dans unevue signifie unemeilleure performanceau runtime

Utilisable uniquement pour uneseule liaison et seulement dansune vue.

Liaison devariable

x Facile à configurer Possibilités limitées dedynamisation


x Rapide et clair; pourplages de valeurs oualternatives multiples,performance élevée auruntime

Pas utilisable pour toutes lesdynamisations



Type dedynamisation

S B Avantage Inconvénient

Action en C x x Possibilités presqueillimitées dedynamisation avec lelangage de scriptsperformant (Ansi-C)

Risques d'erreurs par suited'instructions C erronées

Moindre performance par rapportaux autres modes dedynamisation; toujours s'assurerque l'objectif ne peut pas êtreatteint par un autre mode dedynamisation.

Légende:

A : Dynamisation de la propriété d'objetB : Dynamisation de l'événement d'objet

Appel des dialogues pour la dynamisation

Dialogue Appel

Dialogue deconfiguration

Tous les objets ne possèdent pas un tel dialogue.

Appel automatique à la création de ces objets.

Sélectionner un objet dans une vue; en appuyant sur la touche

MAJ et en la maintenant enfoncée, cliquer GG.

Sélectionner un objet dans une vue, cliquer D pour ouvrirle menu contextuel Dialogue de configuration

Dynamic Wizard Sélectionner un objet dans une vue; Sélectionner Propriétés ou

Evénement. Sélectionner l'assistant et lancer avec GG.L'assistant Dynamic Wizard doit être sélectionné avec lescommandes Affichage Barres d'outils.

Liaison directe Sélectionner un objet dans une vue; afficher les propriétés del'objet; sélectionner l'onglet Evénement; dans la colonne

Action, cliquer D pour ouvrir le menu contextuel. Sélectionner Liaison directe.

Liaison de variable Sélectionner un objet dans une vue; afficher les propriétésd'objet; sélectionner l'onglet Propriétés; dans la colonne

Dynamisation, cliquez D pour ouvrir le menu contextuel. Sélectionner une variable. Dans le dialogue, sélectionner lavariable correspondane et validez-la.


Sélectionner un objet dans la vue. Afficher les propriétésd'objet; Sélectionner l'onglet Propriétés; dans la colonne

Dynam., cliquez D pour ouvrir le menu contextuel Dialogue de dynamisation. Dans le dialogue, configurer etappliquer la dynamisation correspondante

Action C Sélectionner un objet dans la vue. Afficher les propriétésd'objet. Sélectionner l'onglet Propriétés ou Evénement;

dans la colonne Dynam. ou Action, cliquer D pour ouvrir lemenu contextuel; Sélectionner Action C. Configurerl'action C correspondante et la compiler



Résultats et visualisation

Dialogue Résultat Visualisation

Dynamic Wizard Il y a toujours création d'uneAction en C.

Flèche verte

Liaison directe Flèche bleue

Liaison de variable Ampoule verte

Dialogue de dynamisation Action C (InProc) généréeautomatiquement; cetteaction en C peut être ensuiteétendue, mais l'avantage desmeilleures performances estalors perdu.

Flèche rouge

Changement en Flèche vertesur modification dansl'action en C

Action en C Script C configuré Flèche verte

Flèche jaune - l'action doitêtre encore compilée



3.3.3 Environnement systme WinCC

WinCC est rangé par défaut dans le répertoire C:\Siemens\WinCC\. Le chemin standard peut êtremodifié pendant l'installation.

3.3.3.1 Structure des répertoires de WinCC

La structure du répertoire WinCC, sans les options et sans les exemples, est la suivante.

Fichiers dans le répertoire standard WinCC

Dans le chemin de WinCC standard, les répertoires et fichiers suivants intéressent le responsable de laconfiguration et de la mise en service.

Répertoire Nom de fichier,extension

Remarque

Diagnostic License.log Entrées courantes dans le journal concernant lesvérifications et violations de licences

License.bak Fichier journal des informations de licences dudernier démarrage

WinCC_Op_01.log Messages générés par WinCC au runtime.

WinCC_Sstart_01.log

Messages système générés par WinCC au démarrage.Fichier très important pour la recherche d'erreurs. Lefichier contient des messages sur les variablesmanquantes, les scripts mal exécutés.

WinCC_Sys_01.log Messages système générés par WinCC au runtime.Fichier très important pour la recherche d'erreurs. Lefichier contient des messages sur les variablesmanquantes, les scripts mal exécutés.

S7chn01.log Messages système du canal utilisé (en l'occurrenceS7)

aplib Voie d'accès debibliothèque

Fichiers d'en-tête; toutes les fonctions standard ettoutes les fonctions internes sont rangées dans dessous-répertoires.




Dans le chemin WinCC standard, les fonctions et symboles valables pour tous les projets sont rangésdans les répertoires suivants:

Répertoire Sous-liste , Nom de fichier Remarque

aplib library.pxl Symboles de la bibliothèque standard deWinCC

Report, Wincc, Windows Répertoires des fonctions standard;ceux-ci peuvent être adaptés à toutmoment.

Allocate, C_bib, Graphics, Tag Répertoires des fonctions internes; nepeuvent pas être adaptés.

syslay Tous les modèles de travauxd'impression copiés automatiquementpar WinCC dans le chemin de projetdans le répertoire prt, à la création d'unprojet.

wscripts Dynwiz.cwd L'assistant Dynamic Wizard deGraphics Designer. Possibilités de créerses propres scripts à tout moment. Cesscripts ont toujours l'extension .wnf

wscripts.deu Ce chemin contient les fichiers de scriptspour l'allemand. Ce chemin est fonctionde la langue installée.

Wscripts.enu Ce chemin contient les fichiers de scriptspour l'anglais. L'anglais étant la languepar défaut, ce chemin est toujours créé.

Wscripts.fra Ce chemin contient les fichiers de scriptspour le français. Ce chemin est fonctionde la langue installée.




Les programmes utilisateur ci-dessous sont rangés dans les répertoires ci-après lors de l'installation deWinCC:

Répertoire\ Fichier Remarque

\sqlany\isql.exe Programme interactif permettant de consulter une base dedonnées d'un projet WinCC.

\bin\Wunload.exe Assistant (Wizard) servant à vider les tableaux en ligne dans labase de données du projet WinCC, p. ex. suppression des alarmeset des données de points de mesure.

L'assistant paramètre automatiquement les tables du runtime pourle déchargement; l'utilisateur peut cependant ajouter ousupprimer d'autres tables dans la liste à tout moment.

Cet outil doit être utilisé hors connexion (hors ligne) pour unprojet WinCC. Cet outil n'est pas utilisable en mode runtime.L'exportation des alarmes et des valeurs de mesure au runtime estpossible avec le package optionnel STORAGE.

\bin\Wrebuild.exe Assistant (Wizard) pour la restauration de la base de données; nepeut pas être utilisé au runtime!

\SmartTools\CC_GrafikTools\metaVw.exe

Composant d'affichage de fichiers graphiques (p. ex. travauxd'impression, symboles exportés) au format EMF (extended metafile).

\SmartTools\CC_GrafikTools\wmfdcode.exe

Composant d'affichage de fichiers graphiques au format WMF(windows meta file).

\SmartTools\CC_OCX_REG\ocxreg.exe

Pour enregistrement ou suppression d'autres composants OLE(OCX).

\SmartTools\CC_OCX_REG\Regsvr32.exe

appelé par ocxreg.exe.



3.3.4 Environnement de projet WinCC

Remarque:Créez pour vos projets WinCC un répertoire de projets spécifique, p. ex. WinCC_Projets.Ceci permet d'obtenir une séparation claire entre le système WinCC et les donnéesconfigurées. La sauvegarde des données s'en trouve facilitée. Le risque de perte de données(par erreur de manipulation) lors d'une désinstallation de WinCC est ainsi très largementévité.

3.3.4.1 Projet WinCC - Structure de répertoires

Un projet WinCC est constitué d'une structure globale de répertoires et de leur contenu. Après avoircréé un nouveau projet dans WinCC Explorer (par les commandes de menu Fichier Nouveau),procédez comme suit pour construire une structure de fichiers:

WinCC Standard WinCC avec options



Contenu des répertoires de projet

Répertoire Extension Remarque

Chemin de projet .db Base de données contenant les informations deconfiguration

rt.db La base de données avec les données de runtime,les valeurs de mesure, les alarmes

.mcp (mastercontrolprogram)

Fichier principal du projet WinCC. Ce fichierouvre le projet.

.pin Projet.pin

GraCS .pdl (picturedesignlanguage)

Les vues configurées

.sav Fichiers de sauvegarde des fichiers de vue avecl'état de configuration le plus récent

.gif (bitmap),

.wmf (windowsmeta file),

.emf (extendedmeta file)

Fichiers de vue

.act (action) Actions C exportées

.pdd Default.pdd Paramètres de configuration pourl'éditeur graphique (paramétrages par défaut desdivers objets dans la palette d'objets)

Library .h (header) Ap_pbib.h (Déclarations de fonctions de projet)

.pxl Library.pxl (bibliothèque de symboles de projet)

.fct Fonctions de projet

.dll (dynamiclink library)

Bibliothèques de fonction propres créées avec unenvironnement de développement C.

Alar

Pas .pas (définitiond'actions)

Actions de projet exécutées en arrière-plan enfonction du déclencheur paramétré

Pass

Pde

Prt .rpl (reportpicturelanguage)

.rp1 (...modèlede ligne)

Modèles de travaux d'impression

Les modèles standard WinCC prédéfiniscommencent toujours par @. Toutes les grandeursdu système (également variables) sont caractériséespar ce préfixe.

Nom d'ordinateurp. ex. Zip-ws1

\GraCS\GraCS.ini

Fichier d'initialisation de l'éditeur graphique



Option: Fichiers pouvant être créés pendant la configuration

Répertoire Extension Remarque

en partie librementdéfinissable

.ini Fichier d'initialisation du simulateur avec informationsd'appel.

.sim Variables internes avec paramétrages pour lasimulation

.csv Textes exportés depuis la bibliothèque de textes

.txt Alarmes exportées depuis le système d'alarmes (AlarmLogging)

.emf Travaux d'impression d'impression dans un fichier

.log Fichiers Log

.xls

.doc

.wri

Fichiers créés avec d'autres applications que WinCCmais utilisés dans un projet WinCC



3.3.5 Démarrage automatique de projet WinCC

Condition

Le système HIM (WinCC) doit être lancé automatiquement au démarrage du système Windows.L'opérateur à la station IHM n'a besoin d'aucune connaissance de la manipulation de Windows (p .ex.chargement de WinCC sous Windows NT).

Solution

WinCC est lancé automatiquement à l'allumage du PC par la routine de démarrage. Ce paramétrages'effectue dans le dossier Démarrage auto de Windows.

Création de liaisons

Etape Procédure pour NT4.0:

1 Dans Windows Explorer, passez dans le répertoire WinNT\Profiles\AllUsers\Startmenü\Programme\Autostart. WinNT est le répertoire dans lequelWindows NT a été installé

2Dans le dossier, créez une nouvelle liaison avec les commandes DNouveau Liaison

3 Créez la liaison au programme mcp.exe (Master Control Program) dans lerépertoire \bin de WinCC.

4 Attribuez un nom à la liaison.

WinCC est alors démarré automatiquement. WinCC est automatiquement lancé avec le projetdernièrement édité ou activé.Pour démarrer un système en mode runtime, le projet doit donc avoir été quitté dans l'état activé.

Remarque:Si la combinaison de touches CTRL + MAJ n'est pas verrouillée, WinCC démarre en modeconfiguration lorsqu'on appuie sur cette combinaison de touches au démarrage de WinCC,même si le projet a été quitté à l'état activé.

L'opérateur voit alors la vue de démarrage du système qui lui est familière. Pour que l'opérateur nepuisse pas, par inadvertance ou intentionnellement, basculer en configuration (exécutée en arrière-plan) ni utiliser des applications Windows qu'il n'est pas habilité à manipuler, des mesures deprécaution appropriées doivent être prises. L'opérateur ne doit pas non plus accéder à la fenêtre deruntime de la base de données, car il pourrait ainsi mettre fin à la connexion à la base de donnéesWinCC.



Pas de sélection des modules ci-dessous au runtime:

L'opérateur ne doit pas avoir la possibilité de sélectionner les modules ci-dessous au runtime:

• WinCC Explorer de WinCC (environnement de programmation),

• la fenêtre de runtime de la base de données SQL de WinCC (Sybase SQL Anywhere), unutilisateur pouvant sinon interrompre la connexion à la base de données. WinCC ne peut plusfonctionner,

• la barre de tâches de Windows, car ainsi tous les programmes installés peuvent être démarrés,

• la fenêtre de la tâche courante, l'application risquant d'être quittée.

Paramétrage nécessaire de l'ordinateur

Pour interdire ces manipulations à l'opérateur, les combinaisons de touches ci-dessous doivent êtreverrouillées.

Le verrouillage se fait dans WinCC Explorer, dialogue Propriétés - Ordinateurs.La signification exacte des diverses combinaisons de touches est indiquée dans l'aide de WinCC etdans l'aide du système d'exploitation correspondant.



Paramétrage nécessaire du runtime

L’activation des boutons standard de Windows pourrait fermer la vue de process; ceci pourrait fairequitter WinCC intempestivement. Pour l'éviter, les propriétés de la vue de process doivent êtreparamétrées de la manière suivante:

Le verrouillage se fait dans WinCC Explorer, dialogue Propriétés - Ordinateurs.La signification exacte des diverses combinaisons de touches est indiquée dans l'aide de WinCC etdans l'aide du système d'exploitation correspondant.

• L'interface utilisateur du système d'exploitation est à nouveau accessible lorsque les commandesModification de taille et Minimiser ne sont pas désactivées.

• La commande Fermer (pas représentée dans la vue) doit également être désactivée. Sinon, vouspouvez quitter le runtime et passer dans le système de configuration.

Remarque:Lorsque les touches mentionnées sont verrouillées en totalité ou en partie, la possibilité doitêtre donnée au technicien chargé de la configuration ou au personnel de maintenanced'accéder à la configuration au moyen d'une touche spécialement configurée à cet effet.Ceci est également valable pour l'arrêt cordonné du système informatique.

Ces fonctions ne doivent pas pouvoir être utilisées librement. Une protection d'accès, p. ex. pour lepersonnel maintenance, doit être enregistrée derrière la propriété Mot de passe du bouton.



3.3.6 Sortie coordonne de WinCC

Quitter le système en préservant l'intégrité du système

Pour maintenir le système dans un état cohérent, il est très important de quitter correctement WinCC.Vous devez toujours quitter en premier le runtime WinCC avec le bouton prévu à cet effet. Ce n'estqu'ensuite que vous pouvez fermer le projet dans WinCC Explorer.Si vous ne respectez pas cette règle, cela peut entraîner une perte de données, une détérioration de labase de données et, dans l'hypothèse la plus défavorable, un plantage.

Arrêt par commande opérateur

Une station WinCC ne doit jamais être mise hors tension sans que le système d'exploitation ait étépréalablement arrêté. Le système IHM n'est pas adapté à l'utilisation d'un interrupteur d'arrêtd'urgence. Il devra donc être configuré un bouton de commande permettant à l'opérateur de quitter lesystème de manière cordonnée sans devoir posséder de connaissances supplémentaires.

Coupures de courant

Un concept détaillé de sauvegarde de données doit être élaboré et déployé pour le système IHM afind'éviter, dans la mesure du possible, des pertes de données par variation de tension ou coupure ducourant.

Prévoir impérativement pour la station WinCC une alimentation électrique ininterruptible. Celle-cipourra être réalisée par branchement sur l'onduleur général ou par connexion d'un onduleur dédié auserveur WinCC. Ceci est valable pour les systèmes mono et multiposte, indépendamment du systèmed'exploitation utilisé (Windows NT).L'ASI doit intégrer un logiciel de coupure pour Windows NT permettant, en cas de panne de réseauavec coupure du courant au bout d'un laps de temps, d'arrêter automatiquement le systèmed'exploitation et toutes les applications actives sans perdre de données ; p .ex.: APC USV 600 aveclogiciel de coupure pour Windows NT.

Remarques sur l’installation d’un onduleur

Le branchement d'un onduleur avec logiciel associé suppose la disponibilité d'une interface série. Siaucune interface série n'existe sur la station WinCC, parce qu'elle est p. ex occupée par uneimprimante ou un API, il est nécessaire d'utiliser une carte d'interfaçage supplémentaire.Les interfaces série à affectation multiple (p. ex. par switch) ne sont pas supportées par la plupart dessystèmes d'onduleur et ne sont pas souhaitables non plus car une surveillance permanente du systèmeest alors nécessaire.Un service de surveillance est installé dans le système d'exploitation. Ce service de surveillance doitposséder les paramètres d'arrêt afin de garantir l'arrêt cordonné du système. Le processus d'arrêt dulogiciel applicatif doit être dans tous les cas activé pour que WinCC puisse être arrêté sans perte dedonnées en cas de coupure. Le temps de sauvegarde avant coupure qui est sélectionné doit êtresuffisamment long et tenir compte des applications actives.Le logiciel d'onduleur possède généralement aussi un arrêt temporisé,p. ex. pour le week-end ou lanuit. Ce dispositif permet de quitter le système WinCC sans manipulation.



3.3.7 Sauvegarde des données

Quand doit-on sauvegarder?

Un projet WinCC doit être sauvegardé à plusieurs reprises pour les raisons suivantes:

• Sauvegarde des données pendant la phase de configuration.

• Sauvegarde avant exportation et avant importation de données (p. ex. à l'importation de variables,de textes de vue multilingues, de textes d'alarmes et de textes d'alarmes multilingues).

• Sauvegarde avant la création ou le déchargement de la base de données WinCC.

• Sauvegarde avant le traitement de la base de données avec des outils tels que Accès SQL interactif.

• Sauvegarde des données de configuration pour l'installation sur l'ordinateur cible du client final.

• Reprise de données pour un projet de structure similaire.

Quels sont les supports de mémorisation appropriés?

Support Avantage Inconvénient

Disquettes lisibles presque partout trop faible capacité (mêmeavec compression)

Disquettes ZIP bon marché, capacitésuffisante, accès direct etrapide par Windows; facilitéd'installation; mobile, pourl'utilisation sur le systèmeinformatique

Lecteur de bande (p. ex. surréseau)

possibilité de sauvegardeautomatique (journalière);très grande capacité

disponible généralement enenvironnement bureautiqueseulement; pas d'accès directaux données car utilisant unformat spécial pourl'enregistrement

Disque dur sur autre PC (p.ex. Laplink)

pas de manipulation desupports physiques; donnéesdirectement utilisables

lent; pas approprié pour lesgros volumes de données

Disque MO grande sécurité des données;réutilisabilité; possibilité desauvegarde des alarmes etvaleurs de mesure auruntime.

un lecteur spécial estnécessaire pour l'écriture etla lecture

CD-ROM capacité élevée ;lisiblepresque partout; adapté àl'archivage longue durée.

un lecteur spécial estnécessaire pour la gravure;support pas réutilisable



Nettoyage des projets avant la sauvegarde des données

Afin de sauvegarder un projet sous une forme aussi propre que possible, pour le remettre au clientfinal ou pour la réutilisation de données de projet, les données ci-dessous peuvent être supprimées ounettoyés à l'aide d'utilitaires add-ons.

• Tous les fichiers de sauvegarde du répertoire \GraCS\*.sav du projet.

• Si l'utilisateur n'a pas créé ses propres modèles (Report Designer) pour la documentation, lesmodèles système peuvent être supprimés dans le répertoire \Prt. Lors de la création d'un nouveauprojet, tous les modèles système sont automatiquement copiés depuis le répertoire\Siemens\WinCC\syslay dans le répertoire de projet.

Que doit-on sauvegarder?

Lorsque seules les données d'un projet WinCC doivent être sauvegardées, effectuez la sauvegarde desfichiers et répertoires ainsi que de leurs fichiers suivants.Depuis le répertoire de projet:

• les fichiers *.mcp, *.pin, *.db

• les répertoires \GraCS et Library.

• le répertoire \Pas si l'utilisateur a créé ses propres actions

• le répertoire \Prt si l'utilisateur a créé ses modèles de travaux d'impressionLorsque des composants non spécifiques au projet on été créés (fonctions standard, objets dans labibliothèque de projets),dem WinCC-Standardverzeichnis:

• les fichiers \Siemens\WinCC\aplib\*.fct

• le fichier \Siemens\WinCC\aplib\library.pxldoivent en outre être sauvegardés depuis le répertoire standard WinCC. Ces données ne sont pasgénérées lors d'une nouvelle installation de WinCC.



3.3.8 Copier un projet WinCC sauvegardé sur une nouvelle machine cible

Installation du logiciel système

Installation du logiciel WinCC. Sur les systèmes complets, ceci s'effectue dans le dialogue deconfiguration appelé automatiquement ou depuis le CD d'installation livré avec WinCC et lesdisquettes de licences associées.

Logiciels optionnels et add-ons

Si votre projet utilise des utilitaires spéciaux (p. ex. packages optionnels ou Add-ons) ou desinterfaces de communication spéciales ou encore des interfaces à d'autres programmes Windows (p.ex. WORD, EXCEL, etc.), ces logiciels doivent être également installés sur l'ordinateur cible. Lesautorisations pour logiciels optionnels, Add-ons ou interfaces de communication (DLL de canauxutilisés) doivent également être installées sur la machine cible. Notez que toutes les autorisationsnécessaires (pour toutes les DLL de canaux) doivent être chargées avant de pouvoir travailler avec leprojet WinCC.

Logiciel Windows

Lorsque les vues WinCC utilisent des liaisons OLE à d'autres programmes Windows, p. ex. WORD,ClipArts ou EXCEL, le logiciel correspondant doit être également installé sur la machine cible enfonction du type de liaison OLE, c'est-à-dire qu'il doit être enregistré dans la base de registres deWindows.

OCX, ActiveX

Lorsque d'autres composants OCX (Contrôles OLE, ActiveX) des packages complémentaires sontutilisés, ceux-ci doivent également être enregistrés dans la base de registres de Windows. Enregistrezou vérifiez les enregistrements de ces composants OCX p. ex. à l'aide de l'utilitaireSmartTools\CC_OCX_REG\ocxreg.exe livré sur le CD WinCC. Si le système ne trouve pas unenregistrement d'objets OLE ou d'objets OCX au lancement du projet WinCC au runtime (ainsi quedans la configuration avec Graphics Designer), cet objet est affiché avec le message "Objet inconnu".

Réseau

Si le projet a été configuré pour un système multiposte, l'installation complète du réseau doit avoir étéeffectuée sur la machine cible WinCC avant de copier les données WinCC. Notez les nomsd'ordinateur nécessaires dans l'environnement d'ordinateurs configuré, ceux-ci étant demandés pour leparamétrage du projet copié. Le nom d'ordinateur est également nécessaire pour paramétrer unsystème monoposte; c'est pourquoi vous devez toujours connaître les noms attribués sur la machinecible ou les lire dans le panneau de configuration Windows.

Copie des données et démarrage du projet

Etape Procédure pour la réutilisation de données

1 Création d'un répertoire de projet (p.ex. Projets_WinCC)

2 Copiez l'ensemble du chemin sauvegardé dans le répertoire ainsi créé commesous-répertoire (p. ex.:\WinCC_Projets\Varia_00). Le nom du répertoire deprojets WinCC peut être modifié. Lorsque les fichiers sont renommés dans lerépertoire de projets (varia_00.mcp, varia_00.db, varia_00.pin, varia_00.log),veillez à ce que tous les fichiers aient bien le même nom (sauf l'extension).

3 Ouvrez le projet dans WinCC Explorer.



Etape Procédure pour la réutilisation de données

4 Modifiez le paramétrage spécifique au projet si nécessaire. Pour la modificationdu type, des adaptations supplémentaires sont nécessaires dans Propriétés -Ordinateurs. Ces adaptations sont décrites dans l'aide WinCC.

5 Vérifiez le nom de l'ordinateur et le modifier le cas échéant dans l'onglet Généraldu dialogue Propriétés - Ordinateurs. Si le nom d'ordinateur du projet WinCC necoïncide pas avec le nom d'ordinateur du système cible, un message d'erreur estaffiché à l'activation du projet, c.-à-d. au démarrage du runtime.

6 Si l'on a utilisé dans le projet ses propres fonctions standard (*.fct), copiez lesfonctions standard sauvegardées dans le chemin standard WinCC\Siemens\WinCC\aplib et déclarez-les ensuite dans l'arbre des fonctions.

• Appelez l'éditeur Global Script dans le projet ouvert

• Recréez la structure de déclaration par les commandes de menu Options Regénérer l'en-tête.

Les nouvelles fonctions sont alors visibles dans l’arbre des fonctions.

7 Activez le projet pour vérifier le lancement correct du projet.



3.3.9 Rutilisation - Reprise de parties de projet dans un nouveau projet ou dansun projet existant

Raison de la réutilisation

Un projet WinCC peut être créé de différentes façons. Les aspects les plus importants sont laréutilisabilité d'éléments existants dans des projets semblables ou la reprise de données dans lesexemples de projet.

Equipe de projet

En cas de programmation en équipe, les tâches à réaliser sont similaires car en fin de compte leséléments du projet WinCC devront être fusionnés en un seul projet.Un projet WinCC est constitué de fichiers (p. ex. vues) et des données de configuration enregistréesdans la base de données (système d'alarmes, gestion des variables).

Données stockées dans la base de données

Les données rangées dans la base des données de configuration ne peuvent pas être créées dans deuxprojets individuels et ensuite regroupées.C'est pourquoi il faut, lors de la configuration d'informations de base de données (p. ex. conceptiondes systèmes d'alarmes), créer un projet type qui sera utilisé pour ce genre de configuration. Ce projettype doit être sauvegardé avant chaque modification du contenu de la base de données (également lorsd'opérations intermédiaires). En cas d'incident pendant la modification des données, l'état des donnéesantérieur à la modification est alors disponible.

Remarque:Notez que toute modification du contenu de la base de données influe sur sa structure et surl'accès à cette base. Un grand nombre de modifications superflues (avec le cas échéant dessuppressions de données) peuvent avoir des conséquences néfastes sur l'organisation de labase de données WinCC (perte de performances).

Système monoposte

Pendant que la phase suivante de configuration, p. ex. du système d'alarmes, est effectuée à la stationprincipale, vous ne devez en aucun cas modifier la base de données sur un autre ordinateur (p. ex. unarchivage – Tag Logging) lorsque le système WinCC est monoposte.

Système multiposte ou multiclient

Par contre, sur un système multiposte ou multiclient WinCC sur lequel vous configurez un projet,vous pouvez configurer simultanément plusieurs domaines d'une base de données. Une personne peutp. ex. configurer le système d'alarmes et une autre le système d'archivage (acquisition de valeurs demesure par exemple).



Modification de typ de projet - Conversion:Monoposte - Multiposte

Tous les projets peuvent être convertis pour passer d'un système de configuration WinCC quelconquedans un autre système de configuration. Lorsque l'on prévoit la transformation de station(s) deconfiguration en systèmes client, n'utiliser aucun élément WinCC spécifiquement conçu poursystèmes multiposte. Ne pas utiliser, par exemple, de variables internes locales spécifiques à unordinateur si le système doit être installé en monoposte chez le client.On doit savoir à la création d'un nouveau projet (monoposte ou multiposte) si un projet type existantdoit être utilisé comme point de départ avec son système d'alarmes préconfiguré et ses donnéesd'archivage. Les données rangées dans la base de données ne sont transférables dans d'autres projetsque par reconfiguration ou, lorsque cela est possible, par exportation - importation.

3.3.9.1 Réutilisation de vues

Les vues configurées peuvent être réutilisées à tout moment. Vous pouvez procéder de deux manières:copier, dans l'explorateur Windows, les fichiers de vue (*.pdl) directement, depuis le répertoire sourcedans le répertoire cible, dans le chemin de projet WinCC \GraCS (méthode appropriée pour plusieursfichiers de vue);Ci-dessous un extrait du projet pour la configuration de vue.

La deuxième manière de réutiliser des vues consiste à ouvrir un fichier de vue (bild.pdl) dansGraphics Designer par la commande de menu Fichier. Vous devez ensuite enregistrer la vuedans le répertoire de vues courant (\GraCS) par les commandes de menu Fichier Enregistrersous.... Cette procédure est bien adaptée lorsque les fichiers de vue doivent être pris comme point dedépart et adaptés immédiatement.



Références dans les vues

• Structures du domaine Type de données

• Variables internes ou externes

• Variables système

• Objets de vue mémorisés au format Bitmap ou comme métafichier (p. ex. pour les indicateursd'état ou les objets graphiques)

• Autres vues utilisées comme boîtes graphiques ou boîtes de process ou fenêtres affichées

• Fonctions de projet utilisées

• Autorisations d'accès

Les références suivantes doivent en outre être définies:

• Définition des structures dans Types de données, p. ex. structures de régulateurs ou de modèlespour objets utilisateur

• Définition des canaux de communication et des liaisons logiques avec définition des variables(éventuellement avec groupes de variables)

• Définition des variables internes et noms des variables système (commençant par @)

• Réutilisation des éléments de vue (*.gif bzw. *.emf) par copie depuis le répertoire \GraCS

• Réutilisation de contenus de fenêtres de vue par copie des autres fichiers de vue (*.pdl) depuis lerépertoire \GraCS

• Les fonctions de projet utilisées doivent être copiées dans le répertoire \library du nouveau projetdepuis le projet source. De plus, ces fonctions doivent être rangées dans l'arbre de fonctions avecl'éditeur Global Script via Générer en-tête. Cette procédure a déjà été décrite de façon plusdétaillée au chapitre Environnement de développement de scripts C.

• Définition des autorisations d'accès utilisées dans l'éditeur User Administrator. Les autorisationsd'accès utilisées (p. ex. pour les boutons de commande) doivent être attribuées pour les définitionsde groupes.



3.3.9.2 Réutilisation de symboles et de bitmaps

Copie

Les symboles utilisés pour l'affichage des états et pour les objets graphiques des fichiers de vue sontmémorisés sous forme de fichiers propres dans le répertoire de vues du projet. Pour cela, copiez lesfichiers de symboles souhaités (*.emf oder *.gif) dans le répertoire de destination \GraCS du nouveauprojet. Ces vues sont alors immédiatement disponibles dans la liste visualisée pour les indicateursd'état ou les objets graphiques (voir palette d'objets dans Graphics Designer). Extrait du dialogue deconfiguration de l'indicateur d'état.

Sélection de vue pour l'objet graphique:



Importation

Vous pouvez intégrer des symboles dans une vue par la méthode qui vient d'être décrite oudirectement avec les commandes de menu Coller Importation dans la vue graphique en coursd'édition. Dans ce cas, vous ne devez pas copier de fichier: vous importez le symbole souhaitédirectement en accédant par le chemin du projet source (\GraCS) au fichier de symbole souhaité(*.gif, *.emf, *.wmf). Après l'importation, le symbole apparaît directement comme objet dans la vue(en haut à gauche).Lorsque des symboles ont été rangés dans une bibliothèque de projets, cette bibliothèque de projetspeut être réutilisée dans un autre projet par reprise de la totalité de la bibliothèque de projets. Voirdescription ci-dessous.

3.3.9.3 Réutilisation de symboles d'une bibliothèque de projet (de symboles et d'objetsutilisateur préconfigurés)

Bibliothèque globale

Lorsque des symboles ont été rangés dans une bibliothèque de projets, celle-ci peut être réutilisée dansun autre projet par copie du fichier library.pxl dans le chemin \library.Les composants préconfigurés peuvent être maintenant réutilisés à n'importe quel moment dans lenouveau projet:

Remarque:Notez que les symboles liés peuvent renvoyer à des références (ou des variables)inexistantes que vous devez donc tout d'abord définir. Les actions ou liaisonscorrespondantes doivent être éventuellement adaptées en fonction de la configuration deces symboles. Il faut donc vérifier après avoir repris des symboles dans la bibliothèquequelles propriétés/liaisons à des événements existent déjà et si ces propriétés/liaisonsdoivent être éventuellement adaptées.



Symboles individuels

Lorsque certains symboles de la bibliothèque de projets sont réutilisés dans un nouveau projet, ceux-cisont exportés individuellement (fichier symbole *.emf).

Etape Procédure: Réutilisation de symboles

1 Ouvrir la bibliothèque

2Sélectionnez le symbole souhaité par et faites glisser ce symbole dans la vueen maintenant le bouton de la souris enfoncé (Glisser-Déposer).

3 Chargez le dialogue d'enregistrement du symbole par les commandes Fichier Export... .

4 Enregistrez le symbole

Nouvelle bibliothèque de projets

Ces symboles exportés sont maintenant disponibles sous forme de fichiers de symboles réutilisablesindividuellement par importation. Si ces symboles sont utilisés fréquemment dans le projet, ils doiventêtre ajoutés à la nouvelle bibliothèque de projets. Pour cela, appelez la bibliothèque de symboles etparticulièrement la bibliothèque de projets:Créez un répertoire de symboles spécifique, p. ex. à l'aide du symbole de répertoire de la barre d'outilsde la fenêtre de bibliothèque et copiez les symboles importés dans ce répertoire par Glisser?époser. Decette manière, vous pouvez réutiliser en partie vos symboles dans des projets existants et y ajouter denouveaux symboles spécifiques afin de recréer une bibliothèque de symboles propre au nouveauprojet.



3.3.9.4 Réutilisation d'actions

Les actions utilisées fréquemment dans un projet ou devant être copiées d'une action d'objet dans uneautre action d'objet sont enregistrées sous forme de fichiers spécifiques. Ces fichiers sont enregistrésdans le répertoire \GraCS avec l'extension .act. Ils peuvent être repris à tout moment par copie depuisle répertoire source dans le répertoire cible.Dans l'éditeur d'actions C, utilisez le bouton Exporter action de la barre d'outils pour enregistrer unfichier d'action dans le fichier de destination que vous avez vous-même nommé (extension .act pouraction).

Le bouton Importer action permet de reprendre dans une vue du nouveau projet un fichier d'actionenregistré pour une action sur un objet. Cette procédure a déjà été décrite de façon plus détaillée auchapitre Environnement de développement de scripts C.

Remarque:Les actions utilisées fréquemment peuvent aussi être définies comme fonctions de projet oufonctions standard.



3.3.9.5 Réutilisation de variables

La gestion des variables de WinCC peut être complétée de différentes manières:

• Chargement de variables de données S5 ou S7 avec l'assistant (Dynamic Wizard)

• Réutilisation de variables S7 au moyen du Mapper PCS7

• Importation et exportation de listes de textes à l'aide de l'outil add-on Var_Exim

• Accès interactif aux tables de la base de données (tables de variables)Assistant spécifiquement programmé (Dynamic Wizard) ou programmes créant de nouvelles donnéesdans la gestion des variables via les fonction API WinCCLes deux dernières possibilités supposent de très bonnes connaissances du maniement des bases dedonnées SQL et de la programmation par interface de programmation d'application (API). Ceci ne doitêtre effectué que par des personnes possédant de telles connaissances.Avant de réutiliser les données dans le projet cible il faut par conséquent examiner où se trouve labase du projet cible. S'il existe déjà un grand nombre de variables dans la gestion des variables deWinCC, il convient d'importer la liste de variables de WinCC dans le projet cible. Les variablesinternes doivent toujours être reprises de la Gestion des variables de WinCC. Utilisez pour cela l'outilVar_Exim.exe.

Réutilisation de variables de données S5-/S7 avec assistant Dynamic Wizard

Les définitions de domaines de données créées avec le logiciel STEP5/STEP7 peuvent être écritesdans la gestion des variables de WinCC à l'aide des assistants Dynamic Wizard existants. Effectuezles opérations suivantes.

Etape Procédure: Réutilisation de données S5 ou S7

1 Effectuez une sauvegarde des données du projet. Des modifications sontréalisées dans la base de données.

2 Exportez la liste de correspondances avec le logiciel STEP. Un fichierprj_zuli.SEQ est créé.

3 Eliminez de ce fichier exporté les symboles spéciaux (p. ex. pour appels deprogramme) qui ne sont pas nécessaires pour l'importation dans WinCC. Cecipeut s'effectuer avec un éditeur de texte (p. ex. Wordpad). La liste decorrespondances ne doit pas contenir de lignes vides.

4 Ouvrez le projet cible dans WinCC Explorer. Le projet doit être en modeconfiguration (runtime pas actif).

5 Ouvrez l'éditeur Graphics Designer. Dans une vue quelconque, dans DynamicWizard (à afficher par les commandes Affichage Barres d’outils ...),sélectionnez l'onglet Fonctions d’importation. Dans cet onglet, sélectionnez lafonction Import S7 – S5 ZULI . Vous devez maintenant nommer (avec le bouton)le fichier source (.seq) en indiquant le répertoire.

Spécifiez en outre la liaison logique par laquelle les descriptions de variableseront rattachées à la liste d'affectations.

Les données sont alors entrées dans la gestion des variables WinCC. Les noms devariables doivent être uniques dans tout le projet WinCC. Les variables sontajoutées à la gestion des variables existant déjà le cas échéant. Le nom devariable constitue la clé.



Réutilisation de variables avec add-on

Les liaisons (DLL de canal, liaisons logiques et paramètres de liaison) doivent avoir été déjà définiesdans le projet cible avant l'importation.

Remarque:Pour créer automatiquement des liaisons et entrer automatiquement des données dans labase de données WinCC, on peut créer un programme spécial réalisant de telles définitionsvia l'interface de programmation WinCC (API). De cette manière, les données de processexistant déjà peuvent être complétées automatiquement. Ceci doit être réalisé par unspécialiste de la programmation par interfaces API WinCC ou de programmation SQL.

Les variables définies dans la gestion des variables peuvent être à tout moment exportées commefichiers texte pour compléter la liste des variables. Les données ainsi créées doivent être réimportéesdans la gestion des variables du projet. Les fichiers créés sont enregistrés au format CSV (commaseparated values) et peuvent ensuite être lus et traités par des programmes de traitement quelconques.

• Il existe pour cela une application rangée dans le répertoire\SmartTools\CC_VariablenImportExport du CD-ROM. Ce programme Windows est fournicomme add-on:

• pour le transfert des données depuis la gestion des variables d'autres supports

• Pour l'importation de données de variables déjà créées en externe

• Pour la configuration de données de masseLes opérations ci-dessous sont nécessaires pour l'exportation ou l'importation de données.



Etape Procédure: Importation et exportation de variables

1 Ouvrez votre projet WinCC dans WinCC Explorer.

2 Définissez les liaisons inexistantes mais nécessaires pour l'exportation ultérieure(DLL de canal– Liaison logique – Paramètres de la liaison). Ceci ne doitcependant être exécuté que dans le nouveau projet. Une nouvelle opérationd'exportation/importation peut être nécessaire.

3Activez le programme Var_exim par GG. L'interface utilisateur de ceprogramme est affichée ci-dessous.



Importation - Exportation

Le paramétrage ci-dessous est nécessaire pour l'exportation ou l'importation:

Localisation,action

Importation Exportation

Chemin Sélectionnez le répertoire deprojet contenant les fichiers pourl'importation de variables. Lasélection se fait par chargementdu fichier .mcp. Les fichierscontenant les données à importerdoivent se trouver dans le mêmerépertoire que le fichier de projet.

Indiquez le répertoire pourl'exportation de variables. Lasélection se fait par chargementdu fichier .mcp.

Action Sélectionnez Import

Si les données de variableexistantes doivent être écrasées,sélectionnez Import overwrite.

Sélectionnez Export.

EXECUTE Sélectionnez Execute

Le dialogue alors affiché montreles paramètres réglés et exécute letransfert des données aprèsvalidation par OK.

Les vérifications effectuées fontque l'importation demande plus detemps.

Sélectionnez Execute

Le dialogue alors affichémontre les paramètres réglés etexécute le transfert des donnéesaprès validation par OK.

Indicateur d'état Fin Exportation/Importation Fin Exportation/Importation

Fichier de variables

Name_vex.csv

Base de données pourl'importation:

constituée d'une ligne d'en-tête etd'enregistrements

La liste de variables créée estmémorisée sous forme de textedans ce fichier. Son contenupeut être consulté directementavec le bouton var ou édité dansun éditeur de texte (Notepad)ou avec EXCEL.

Fichier de variables

Name_cex.csv


constituée d'une ligne d'en-tête etd'enregistrements (champs destructures)

Ce fichier contient les liaisonscourantes configuréesauxquelles se réfère le fichierde variables. Son contenu peutêtre consulté directement avecle bouton con ou édité dans unéditeur de texte (Notepad) ouavec EXCEL.

Fichier destructures

Name_dex.csv


constituée d'une ligne d'en-tête etd'enregistrements

Si des structures sont contenuesdans la base, ce fichier est crééen plus avec des informationssur les structures. Son contenupeut être édité avec un éditeurde texte (Notepad) ou avecEXCEL.

Fichier dediagnostic

Diag.txt

Fichier de diagnostic avecindication des variables n'ayantpas pu être importées.

Le bouton End permet de quitter le programme.



Liste de variables

Le tableau ci-après décrit la structure des listes de variables.

Champ Type Description

Varname char Nom de variable:

Conn char Liaison

Group char Nom de groupe

Spec char Variable interne ou adresse (cohérente avec le type deliaison)

Flag DWORD

Common DWORD

Ctyp DWORD Type de variable

1 BIT2 SBYTE3 BYTE4 SWORD5 WORD6 SDWORD7 DWORD8 FLOAT9 DOUBLE10 TEXT_811 TEXT_1612 Type données brutes13 Tableau14 Structure15 CHAMP DE BITS_816 CHAMP DE BITS_1617 CHAMP DE BITS_3218 Référence de texte

CLen DWORD Longueur des variables

CPro DWORD Variable interne ou externe

CFor DWORD Transtypage

Protocol

P1 BOOL Violation seuil supérieur

P2 BOOL Violation seuil inférieur

P3 BOOL Erreur transtypage

P4 BOOL Erreur d'écriture

P5 BOOL

P6 BOOL

L1 BOOL Valeur de substitution pour violation seuil supérieur

L2 BOOL Valeur de substitution pour violation seuil inférieur

L3 BOOL Valeur de démarrage

L4 BOOL Valeur de substitution pour erreur de liaison

L5 BOOL Seuil supérieur valide

L6 BOOL Seuil inférieur valide

L7 BOOL Valeur de démarrage valide

L8 BOOL Valeur de substitution valide

LF1 double Seuil supérieur




LF2 double Seuil inférieur

LF3 double Valeur de démarrage

LF4 double Valeur de substitution

Echelle

SCF DWORD 1 si échelle définie

SPU double Plage de valeurs process de...

SPO double Plage de valeurs process... à

SVU double Plage de valeurs de variable de ...

SVO double Plage de valeurs variable... à

Liste de liaisons


Conname char Nom de liaison logique

Unit char Unité de canal

Common char Général

Specifique char Paramètres de liaisonspécifiques

Flag DWORD

Liste de structures


Datastructure short Nom de structure ou nom dechamp

Type ID short Identification (utilisée pourCtyp dans liste de variables)

Creator ID short

Pour pouvoir traiter sous EXCEL (Version 7.0 ou 8.0) les listes de textes, vous devez ouvrir lesfichiers exportés avec le type de fichiers texte [*.prn; *.txt; *.csv].



Consignes

Respectez les consignes ci-dessous pour l'adaptation des données de variables dans la liste de textes:

Type dans liste de textes Dans WinCC

Liaisons Description générale Les liaisons logiquesdoivent être définies si ellesn'existent pas déjà!

Description spécifique DLLde canal

Les DLL de canal doiventêtre définies si ellesn'existent pas !

Groupe de variables Pas d'information de groupe

Si des groupes ne contenantaucune variable sont définisdans le projet, ceux-ci nesont pas exportés.

L'information de groupe estgénérée automatiquement àla première variable lors del'importation.

Variables Description générale

Description spécifique

DLL de canal ou variableinterne

DLL de canal ou variableinterne

Les éléments manquantssont remplacés par * àl'exportation.

Les variables ne possédantpas de descriptionspécifique ne sont pasimportées!

Variables du type Structure Affectation selon définitionde la structure dans la listede structures

Affectation au type dedonnées.

Définition structure Définition par le techniciende configuration.

Valeurs/seuils Ne sont pas exportés niimportés avec la liste detexte

Définition par le techniciende configuration.

Procédez à une sauvegarde des données du projet avant d'importer les variables modifiées ounouvelles. Des modifications sont réalisées dans la base de données. Ces modifications ne peuvent pasêtre annulées dans WinCC.



3.3.9.6 Réutilisation de textes multilingues (de vues, d'alarmes)

Textes multilingues des vues

Les textes multilingues mémorisés dans les vues peuvent être repris dans le nouveau projet par copiede la vue.Dans le nouveau projet, la langue doit être ajoutée à la bibliothèque de textes. Vérifiez à cet effet lesparamétrages dans Text Library. Il doit y avoir une colonne par langue !

Les langues ne doivent-elles être reprises que partiellement dans le nouveau projet ?La totalité des informations de texte étant mémorisée pour chaque vue, une reconfiguration estnécessaire dans la langue souhaitée pour chaque vue. Il convient de réfléchir à l'opportunité desupprimer les textes déjà configurés. Le changement au runtime n'est possible que par des boutonsspécialement configurés et pourrait constituer une limitation pour le projet. Si les textes doivent êtremalgré tout supprimés pour une langue déjà paramétrée, il est recommandé d'effectuer l'exportation oul'importation avec l'outil add-on Language.

Réutilisation de vues avec références de texte

• Lorsque les vues réutilisées utilisent des références de texte, les données ci-dessous doivent êtreégalement reprises:

• Réutilisation des variables associées (exportation ou nouvelle définition) de la gestion desvariables du projet WinCC

• Réutilisation des textes de la bibliothèque de textes

• Les variables de référence de texte doivent posséder des identificateurs de texte valides. Vérifiezque les ID de texte correspondent encore bien aux textes.

Réutilisation de textes de la bibliothèque de textes

Si les textes de la bibliothèque de textes ne sont repris qu'en partie, les identificateurs de texte doiventêtre adaptés. La réutilisation de textes de la bibliothèque de textes s'effectue par le mécanismed'exportation/importation dans l'éditeur Text Library.



3.3.9.7 Réutilisation d'alarmes

Le référentiel des alarmes

• a besoin d'être modifié et

• demande un lourd travail de configuration en raison des grandes quantités de données impliquées(données de masse).

On réutilise pour cette raison souvent des données d'alarmes de projets existantes. Les modes deréutilisation ci-dessous sont possibles en fonction de la source de données d'alarme:

• Reprise des informations d'alarmes déjà configurées dans des systèmes antérieurs (p. ex. COROS)

• Importation d'alarmes (individuelles) d'un projet WinCC existantImportation d'informations de la phase d'élaboration du concept

Réutilisation d'alarmes de COROS

La méthode à suivre pour les sources énumérées est la suivante:

Etape Procédure: Réutilisation de textes d'alarme existant dans COROS

1 Exportation dans COROS des informations d’alarmes (mldtexte.txt)

2 Chargez dans WinCC ce fichier d’informations avec Dynamic Wizard Fonctionsd’importation Import Alarmes. Les données sont alors importées dans leprojet WinCC courant.

Réutilisation d'alarmes d'un projet WinCC

Lorsque des alarmes sont reprises d'un projet WinCC existant, il est d'abord nécessaire de vérifier si lesystème d'alarmes cible est structuré de manière identique dans la base de données. Les différencesrésident par exemple dans les blocs utilisateur et les blocs de valeurs de process. Organisez les blocsde données cible si possible dans le même ordre (et avec la longueur des éléments de texte). Vousdevrez sinon procéder à une adaptation dans les différentes colonnes avant l'importation.

Etape Procédure: Réutilisation de textes d'alarme WinCC existants

1 Ouvrez l'éditeur Alarm Logging dans le projet courant.

2 Appelez la fonction d'exportation des alarmes par les commandes de menuAlarmes Exporter alarmes individuelles.



Etape Procédure: Réutilisation de textes d'alarme WinCC existants

3 Indiquez le fichier de texte cible dans lequel les informations d'alarmes à exporterdoivent être enregistrées.

Sélectionnez par Sélection les alarmes à exporter à l'aide des critères p. ex.numéro d'alarme, classe d'alarmes.

4 Lancez la procédure d'exportation avec la commande Exporter. Un fichier detexte contenant les informations d'alarme, séparées par des virgules, est alorscréé.

5 Fermez le projet courant et ouvrez le nouveau projet. Rouvrez l'éditeur AlarmLogging et définissez tout d'abord les classes et types d'alarmes nécessaires.Définissez une alarme par type d'alarme afin de disposer de la structure brutepour l'importation qui va suivre.

6 Pour exporter ces alarmes de base, appelez Alarmes Exporter alarmesindividuelles. Procédez comme aux points 3 et 4.

7 Ouvrez p. ex. dans EXCEL le fichier d'alarmes du projet source et le fichierd'alarmes du projet cible. Les colonnes sont séparées par des virgules.

Comparez la structure des blocs d'alarme et procédez le cas échéant à desadaptations en transposant ou en renommant des colonnes. Entrez dans les blocscontenant les identificateurs de texte l'indice 0. De cette manière, les textes serontautomatiquement organisés dans la bibliothèque de textes à l'importation. Lesanciens identificateurs ne doivent en aucun cas être conservés!

Enregistrez à nouveau le fichier modifié comme fichier de texte

8 Appelez maintenant la procédure d'importation par Alarmes Importeralarmes individuelles.

9 Indiquez maintenant le fichier texte source contenant les informations d'alarmesexportées. Vous devez ensuite décider si les alarmes existantes doivent êtreécrasées à l'importation. L'affectation s'effectue par le numéro d'alarme, qui doitêtre unique dans le projet.

10 Les alarmes sont ensuite importées et viennent compléter votre système d'alarmesexistantes. Contrôlez les affectations importées.



Remarque:Lorsque des données d'alarme sont reprises d'un projet WinCC version 1.10, faire attentionaux noms de colonnes dans le fichier d'alarmes !

Importation d'informations de la phase d'élaboration du concept via calcul EXCEL

Les informations d’alarme sont disponibles dans une feuille de calcul EXCEL. Ces alarmes peuventêtre reprises par transfert des colonnes depuis la feuille dans la structure d'alarmes du projet WinCC. Ilfaut pour cela partir d'un fichier d'alarmes WinCC, qui se crée de la manière décrite ci-dessous:

Etape Procédure: Création d'une structure d'alarmes

1 Ouvrez le nouveau projet dans WinCC Explorer. Ouvrez l'éditeur Alarm Logginget définissez tout d'abord les blocs d'alarmes, classes d'alarmes et types d'alarmesnécessaires. Définissez une alarme par type d'alarme afin de disposer de lastructure brute pour l'importation qui va suivre.

2 Pour exporter ces alarmes de base, appelez Alarmes Exporter alarmesindividuelles.

3 Indiquez le fichier de texte cible dans lequel les informations d'alarmes à exporterdoivent être enregistrées.

4 Lancez la procédure d'exportation avec la commande Exporter. Un fichier detexte contenant les informations d'alarmes, séparées par des virgules, est alorscréé.

5 Ouvrez dans EXCEL le fichier d'alarmes et le fichier d'alarmes nouvellementcréé du projet cible. Les colonnes sont séparées par des virgules.

Créez une ligne par copie pour la classe d'alarmes/le type d'alarme correspondantdans la feuille de calcul. Reprenez les textes d'alarmes, etc. dans les donnéessource et entrez-les dans les blocs correspondants. Par exemple: Bloc 1 Texte d’alarme.

Numérotez toutes les lignes d'alarme (p. ex. à partir de 1). Dans EXCEL, cecipeut être effectué rapidement à l'aide de la numérotation dans la colonne desnuméros d'alarme.

6 Entrez dans les blocs contenant les identificateurs de textes l'indice 0. De cettemanière, les textes seront automatiquement organisés dans la bibliothèque detextes à l'importation. Les anciens identificateurs ne doivent en aucun cas êtreconservés!

Enregistrez à nouveau le fichier modifié comme fichier de texte

7 Appelez dans l'éditeur Alarm Logging la procédure d'importation par Alarmes Importer alarmes individuelles.

8 Indiquez maintenant le fichier texte source contenant les informations d'alarmesexportées. Définissez ensuite les paramètres pour que les alarmes existantessoient écrasées. L'affectation s'effectue par le numéro d'alarme, qui doit êtreunique dans le projet.

9 Les alarmes sont ensuite importées et viennent compléter votre système d'alarmesexistantes avec les informations d'alarmes déjà configurées. Contrôlez lesaffectations importées.



3.3.9.8 Réutilisation de valeurs de mesure

Les définitions des points de mesure, des archives de valeurs de process et des archives utilisateurétant intégrées, avec leurs propriétés, directement à la structure de la base de données, une reprise n'estpas possible (sans accès direct à la base de données et sans connaissances approfondies des bases dedonnées). Cela signifie qu'une reconfiguration de ces archives et de ces points de mesure estnécessaire ou que les données doivent être reprises automatiquement par copie depuis un projet initialglobal au début de la configuration.

3.3.9.9 Réutilisation de modèles de travaux d'impression

Copiez les maquettes de travaux d'impression souhaités *.rpl pour les modèles de pages ou *.rp1 pourles modèles de lignes depuis le répertoire source dans le répertoire \PRT du nouveau projet.

3.3.9.10 Réutilisation d'actions globales

Copiez les actions globales souhaitées ou les actions d'arrière-plan *.pas depuis le répertoire sourcedans le répertoire \Pas du nouveau projet.

3.3.9.11 Réutilisation de fonctions de projet

Copiez les fonctions de projet souhaitées *.fct depuis le répertoire source dans le répertoire Library dunouveau projet. Pour déclarer ces fonctions dans le projet, vous devez, dans l'éditeur Global Scripts,activer les commandes Options Générer en-tête. Cette procédure a déjà été décrite de façonplus détaillée au chapitre Environnement de développement de scripts C.

3.3.9.12 Utilisation de fonctions standard

A la différence des fonctions de projet, il n'est pas nécessaire de copier en plus les fonctions standard.Etant connues de tous les projets WinCC installés sur la station, ces fonctions sont disponiblesimmédiatement pour le projet.

3.3.9.13 Réutilisation de la gestion des utilisateurs

La définition des groupes d'utilisateurs, des utilisateurs et des autorisations d'accès étant intégréedirectement à la structure de la base de données, une réutilisation n'est pas possible. Il est doncnécessaire de procéder à une reconfiguration.La réutilisation automatique de données par copie d'un projet de départ au début de la configurationconstitue une exception.



3.3.10 Commande sans souris

Les vues de process se commandent dans la plupart des cas avec la souris. Le clic de la souris est,parmi les modes de dynamisation, l'événement le plus fréquent et connaissant le plus grand nombre devariantes (clic bouton gauche, appui sur ou relâchement du bouton droit). Il existe cependant dessystèmes commandés en mode mixte ou uniquement au clavier. Les entrées sur terminal opérateur parexemple se font uniquement au clavier.

3.3.10.1 Commande au clavier

• La commande au clavier connaît les possibilités de saisie suivantes:

• Touches de fonction F1 à F12

• Touches de fonction spéciales (p. ex. touches de fonction de terminal opérateur (OP) SF10)

• Touches clavier standard

• Déplacement entre les champs de saisie et commande par touches de sens ou touches spéciales

La configuration des manipulations sans souris doit être examinée au cas par cas pour les domaines deconfiguration suivants:

• Touches de commande dans vue de process (p. ex. pour changement de vue) réalisées

• par touches de fonction

• par touches spéciales

• par touches standard

• Commandes par touches quelconques

• Déplacement par objets de manipulation

• Champs de saisie dans vue de process

• Champs de saisie / affichage (ou entrée/sortie ou E/S)

• Objets de saisie spéciaux (boîtes de cases à cocher, etc.)

• Alarm Logging (fenêtre d'alarmes)

• Commande par touches de fonction

• Commande par touches configurées spécialement

• Tag Logging (fenêtre de courbes ou de tableaux)

• Commande par touches de fonction

• Commande par touches configurées spécialement

• Lancement de travaux d'impression par touche

• Connexion ou déconnexion (login/logoff) au clavier

Les touches sont configurées dans le style Windows typique. Vous retrouverez pour cette raison latouche Windows standard dans la palette d'objets. Cette touche peut être complétée à tout momentpour des éléments graphiques supplémentaires.

Touches de commande



Commande par touches de fonction

Les touches de fonctions F1 à F12 du clavier standard sont fréquemment utilisées comme touches decommande clavier (supplémentaires) pour le changement de vue dans la hiérarchie des vues deprocess. Ces touches de fonction peuvent à tout moment être configurées en 'raccourcis clavier' pourles boutons Windows configurés. Une touche de raccourci définit une commande rapide pour lafonction correspondante.

Les touches de fonction mentionnées peuvent être p. ex. enregistrées comme raccourcis clavier.Celles-ci sont proposées comme boutons de sélection dans le masque de configuration.Lorsqu'une combinaison de touches est nécessaire, p. ex. avec la touche MAJ ou la touche CTRL, laséquence de touches doit être entrée directement dans le champ de définition par appui sur la touchecorrespondante (p. ex. MAJ, F2). Il n'est pas nécessaire de saisir des codes spéciaux.La combinaison de touches choisie est affichée dans le champ de saisie.



Les touches choisies sont enregistrées dans les propriétés de l'objet et peuvent être modifiéesdirectement par le dialogue de configuration ou par la propriété Autres Raccourci clavier.

Action pour touche de raccourci clavier

L'action à déclencher par la touche de fonction définie (définition de raccourci) doit être enregistréesous les événements du bouton Windows. L'événement déclencheur doit être le clic de la souris.L'événement est déclenché au relâchement du bouton de la souris, mais uniquement si le curseur de lasouris se trouve sur l'objet au moment de l'enfoncement et du relâchement du bouton. L'action n’estpas déclenchée lorsqu'elle n'est pas placée directement derrière l'événement clic de la souris, mais, parexemple, derrière l'événement (semblable) Appuyez à gauche! Notez également pour la configurationque la touche de fonction ne peut être utilisée qu'une seule fois dans une vue.



Touches de fonctions spéciales

Lorsque des touches de fonction spéciales, p. ex. les touches du terminal opérateur F13, S1, etc., sontutilisées pour manipuler une vue, ces touches doivent être configurées sous forme de combinaisons detouches. La touche F13 peut être p. ex. affectée à la combinaison MAJ F1. Les combinaisons detouches choisies sont, outre leur utilisation décrite ci-dessus, définies de manière spécifique auhardware. Les définitions de touches spéciales diffèrent en fonction du matériel utilisé. Par exemple,un fichier FI25.key permet la définition des codes de touches pour les PC industriels. Les codescorrespondant à ces touches de fonction sont enregistrés dans ces fichiers spécifiques au matériel. Unefois la définition du clavier adaptée au matériel spécifique - utilisation pour chaque fonction de touchedu code hexadécimal - et après activation des nouveaux codes de touches, ces touches peuvent êtreutilisées dans les vues de process pour leur commande.

Touches standard

Lorsque l'action n'est pas rattachée à la frappe d'une touche de fonction, mais à une touchesélectionnée au clavier standard, p. ex. lettre m, cette touche est enregistrée comme touche deraccourci dans l'objet Bouton Windows.

Commandes par touches quelconques

La forme des touches peut être conçue pour les vues de process. Vous trouverez d'autres touches defonction, p. ex. dans la bibliothèque utilisateur sous Boutons tridimensionnels ou dans les Objetsutilisateur.Les objets conçus spécialement à cet effet qui ne sont pas basés sur le bouton Windows ne peuventêtre configurés à l'aide de la touche de raccourci. Tous les autres objets doivent être configurés à l'aidede l'Evénement de touche de l’objet pour la commande par touches. Il existe pour cela pour chaqueobjet les événements de clavier ci-dessous:

• Enfoncer

• Relâcher

Cet événement de touche doit être disponible pour la configuration éventuelle de la commandeclavier. Lorsqu'on utilise des touches prédéfinies de la bibliothèque utilisateur, il est par conséquentnécessaire de vérifier si cette touche est adaptée à la commande sans souris. Les boutons debasculement des objets utilisateur, par exemple, ne sont pas toujours déverrouillés pour la commandeclavier. Une adaptation peut par conséquent être nécessaire.

Les commandes par touches préconfigurées (p. ex. pour feuilleter dans la hièrarchie des vues) setrouvent dans les packages optionnels (p. ex. Basic Process Control - Picture Tree Manager, etc.).



Lorsque l'un de ces objets est utilisé comme élément de commande, la touche permettant ledéclenchement est configurée derrière l'événement Clavier - Appuyer ou Clavier - Relâcher. Vouspouvez configurer comme action une liaison directe ou une action C.L'événement de touche déclencheur est soit une

• action de touche quelconque soit une

• touche sélectionnée sur le clavier standard.S'il s'agit d'une touche quelconque, vous pouvez utiliser la liaison directe; si, par contre, une frappe detouche particulière doit être testée, vous devez utiliser une action C. L'action C vérifie caractère parcaractère le code de touche entré au clavier avant la poursuite de l'exécution de la séquence constituantl'action:

3.3.10.2 Déplacements par objets de manipulation (champs de saisie et champs decommande)

Tous les objets servant à l'entrée de commandes peuvent être directement cliqués. La transformationdu curseur indique si l'objet peut être manipulé par souris. Comment manipuler ces objets sans souris?

Curseur - pointeur

Les touches de déplacement permettent en runtime de passer d'un objet de saisie à un autre. Ondistingue les:

• objets à curseur (objets de saisie de valeurs) (= objets E/S) et

• les objets à pointeur (d'entrée de commandes)

Les objets E/S se sélectionnent avec le curseur (touche Tab ou MAJ+Tab).Tous les périphérique de commande (la souris, le clavier ou tout autre mode de commande) peuventêtre intégrés en un groupe à commande par pointeur. Les champs d'E/S peuvent être intégrés aussibien à un groupe pointeur qu'à un groupe curseur.



Ordre de positionnement du curseur avec touche TAB

Par l’Ordre TAB (paramétrable par les commandes de menu Edition Ordre TAB Curseur Pointeur), vous pouvez modifier l'ordre de positionnement du curseur ou du pointeur sur les

objets de saisie / de commande dans le mode runtime. L'objet actuellement sélectionné peut êtrevisualisé au runtime. Il s'agit du curseur de runtime, que vous pouvez aussi désactiver (Propriétés -Ordinateurs Graphics Runtime). Lorsqu'ils sont sélectionnés, les boutons de style Windows sonttoujours marqués par un rectangle en pointillés. Le déplacement par les éléments de manipulation estfonction du paramétrage de Graphics Runtime (Propriétés - Ordinateurs Graphics Runtime).

Déplacement Touches standard Paramétrage touches

vers le haut,vers le bas

vers la gauche,vers la droite

Touches de flèche ou

Tabulateur (suivant) ouMAJ Tabulateur(précédent)

Autres paramétrages de touches parPropriétés - Ordinateurs GraphicsRuntime Touches de commandecurseur

Curseur/

Pointeur

Pointeur Basculement entre pointeur et curseur (desaisie) par touches de raccourci(Propriétés - Ordinateurs GraphicsRuntime Touches de raccourci outouches spécifiques (utilisation de lafonction interne SetCursorMode)

Déplacementdans un tableau(groupecurseur)

Déplacement normal,mode ligne

Le comportement se modifie parPropriétés - Ordinateurs GraphicsRuntime Réaction curseur

Champs d'entrée/sortie

Les champs d'E/S configurés peuvent être manipulés directement au clavier dès leur sélection: vouspouvez y entrer immédiatement vos nouvelles donnés. Vous ne pouvez saisir de commandes dans unchamp d'un type programmé uniquement pour des affichages (Propriétés Entrée/Sortie Type de champ Sortie). La confirmation de la saisie s'effectue en fonction de la propriétéconfigurée par (Propriétés Sortie/Entrée Valider en quittant ) par la touche ENTREE. Latouche d'échappement (ESC) met par contre fin à l'affichage sans que la valeur du champ soitmodifiée.

Autres objets de saisie

Outre les champs typiques de saisie de valeurs analogiques, les applications Windows permettentd'autres possibilités de saisie. Ces objets spéciaux se trouvent dans la palette d'objets par ObjetsWindows

• Case à cocher

• Case d'option

L'activation des cases à cocher ou des cases d'option se fait avec la touche d'espacement, ledéplacement entre les diverses case de la boîte avec les touches vers le haut/vers le bas (p. ex. touchesde sens). Ceci est l'affectation de touches standard. La boîte combo est un autre objet de saisie. Unesélection peut être effectuée dans une liste affichant les entrées configurées: La commande peutégalement s'effectuer au clavier. L'enregistrement d'une configuration spéciale n'est pas nécessairepour l'affectation des touches. La liste s'ouvre à l'aide de la touche ENTREE; les déplacements dansla liste se font avec les touches de déplacement vers le haut/vers le bas; la validation de la sélection sefait avec la touche ENTREE. D'autres objets de saisie peuvent être utilisés dans WinCC via descontrôles OCX. La manipulation de ces contrôles et leur configuration sont cependant fonction desévénements et des propriétés disponibles qui ont été définis pour un objet. Ceci doit être élucidé danschaque cas.



3.3.10.3 Touches de fonction Alarm Logging pour boutons de barre d’outils

Dans les fenêtres d'alarme,divers boutons de la barre d'outils se manipulent en standard avec la souris.Les manipulations les plus fréquentes dans une fenêtre d'alarme sont:

• Sélection d'une alarme pour acquittement

• Déplacements vers le haut/vers le bas dans la liste d'alarmes

Feuilleter la liste des alarmes

A l'ouverture de la fenêtre d'alarmes ou à l'entrée d'une autre commande, les commandes par boutonsdoivent être disponibles dans la fenêtre d'alarmes et pas dans la fenêtre principale. Les touches defonction agissent, en fonction de la fenêtre courante, sur le bandeau de boutons de la fenêtre principaleou sur le bandeau de boutons de la fenêtre d'alarmes. Ceci s'obtient par exemple en plaçant le focus decommande dans cette zone de fenêtre. Le focus se positionne normalement en cliquant avec la souris.

Le focus peut être positionné au clavier dans la fenêtre d'alarmes par trois méthodes:

• changement de fenêtre avec touche de raccourci

• positionnement du focus par bouton de commande oupositionnement direct du focus sur un élément défini dans la fenêtre d'alarmes à la sélection de vue.Le basculement dans la fenêtre d'alarmes à l'aide d'un raccourci clavier utilisable à tous leschangements de fenêtre, c'est-à-dire aussi pour les fenêtres de courbes p. ex., se règle dans lesparamètres de lancement de Graphics Runtime. Entrez la combinaison de touches (p. ex. Ctrl W) dansPropriétés - Ordinateurs Graphics Runtime Touches de raccourci Basculer fenêtre.Une fois la fenêtre d'alarmes sélectionnée, cette séquence de touches permet de commanderdirectement les boutons de la barre d'outils.

Le positionnement direct du focus de commande sur la fenêtre d'alarmes s'obtient par contre avec lafonction interne Set_Focus. Une action C affectée à un bouton ou à la sélection de vue (Objet devue Evénement Autres Sélection de vue) peut par conséquent commander l'activationde la commande de la fenêtre des alarmes.

Vous trouverez les fonctions de focus de vue dans Fonctions internes Graphics Set focus. La fonction suivante est appelée par exemple pour activer le focus de commande:

Entrez comme paramètres le nom de la fenêtre principale (nom de vue) et le nom du contrôle Alarm(nom d'objet) .

La sélection d'une alarme dans la fenêtre d'alarmes se fait en sélectionnant la ligne d'alarme. A lasélection de la fenêtre d'alarmes, le curseur se trouve sur l'alarme la plus récente (dernière alarme dansla vue d'alarmes). La possibilité de sélectionner une alarme dans la fenêtre ou de feuilleter les alarmesdépend de l'activation/la désactivation du défilement de l'image.



Vous pouvez activer/désactiver le défilement de l'image par un bouton spécifique de la barre d'outilsou directement par configuration du contrôle WinCC Alarm Control.

Lorsque le défilement de l'image et le focus de commande sont activés dans la fenêtre d'alarmes, lesdéplacements peuvent s'effectuer comme suit:


Déplacements vers lehaut/vers le bas dans la listed'alarmes

Touches de sens Lignes d'alarmes

Début, fin de la listed'alarmes

Touche Pos1, Fin Début ou fin de la vued'alarmes

Feuilleter Touches Feuilleter Plusieurs lignes d'alarmes

Outre la commande standard par la souris, on peut également définir une commande par touche defonction pour activer les boutons de la barre d'outils, p. ex. pour l'acquittement de l'alarmesélectionnée.



Vous pouvez, pour chaque bouton affiché dans la barre d'outils, enregistrer dans les propriétés unecommande clavier correspondante.Par exemple:

Ces opérations de configuration permettent d'affecter une combinaison de touches à tous les boutonsutilisés pour la fenêtre d'alarmes.

3.3.10.4 Boutons de barre d'outils configurés de manière spécifique au process dansAlarm Logging

La totalité des boutons de la barre d'outils sont affichés par WinCC et ne peuvent être modifiés. Si unagencement de boutons est prescrit pour le process à configurer, la barre d'outils WinCC doit êtredésactivée (vous n'avez donc plus de barre d'outils). Vous devez personnaliser vous-même les boutonscorrespondants selon les souhaits du client (p. ex. leur affecter des vues).Il faut cependant également configurer la fonctionnalité des divers boutons sous forme d'action. Dansl'action C liée à l'événement correspondant (p. ex. enfoncer bouton), la fonction standard associée doitêtre sélectionnée dans l'arbre des fonctions. Les fonctions proposées pour les boutons se trouvent dansles Fonctions standard alarm. A chaque bouton de la barre d'outils correspond une fonctionassociée dans la liste. La fonction ci-dessous est par exemple appelée pour le bouton d'acquittement:

Le titre de la fenêtre du contrôle Alarm Logging doit être entré comme paramètre.Ces actions peuvent également être utilisées avec la souris pour les boutons configurés parl'utilisateur.Vous trouverez quelques exemples de ces boutons dans les packages optionnels du système d'alarmes(p. ex. Basic Process Control - Acquittement de klaxon, etc.).



3.3.10.5 Touches de fonction Tag Logging pour boutons de barre d’outils

Dans les contrôles Trend et Table de Tag Logging (fenêtres de courbes et fenêtres de tableaux)affichant des valeurs de mesure (nommées "affichages de tendance"), des boutons manipulables enstandard avec la souris sont placés dans la barre d'outils.

Les principales commandes d'une fenêtre de courbes sont

• Feuilleter les valeurs de mesure (axe des temps)

• Sélection de plage de temps

• Sélection de courbes

• Manipulation de la règle de lecture

Après affichage de la fenêtre de courbes, la courbe est affichée en fonction des paramètres configurés.

A l'affichage de la fenêtre de courbes, les boutons doivent se trouver dans la fenêtre de courbes et pasdans la fenêtre principale. Selon la fenêtre dans laquelle les boutons sont affichés, ces commandes(boutons de fonction) agissent sur le bandeau de boutons de la fenêtre principale ou sur celui desboutons de la fenêtre de courbes ou de tableaux. Ceci s'obtient par exemple en plaçant le focus decommande courant dans cette zone de fenêtre. Le focus se positionne normalement par clic de lasouris.Le focus peut être positionné au clavier dans la fenêtre de courbes ou la fenêtre de tableaux par unedes variantes configurables suivantes:

• changement de fenêtre par touche de raccourci

• positionnement du focus par bouton oupositionnement direct du focus sur un élément défini dans la fenêtre de courbe à la sélection de vue.La réalisation de ces variantes a été décrite au chapitre Alarm Logging.Outre la commande standard avec la souris, on peut également définir des touches de fonction pouractiver les boutons de la barre d'outils, comme p. ex. pour la sélection d'une période. Les touches sontoccupées en standard par les fonctions F1 à F10.Vous pouvez, pour chaque bouton affiché dans la barre d'outils, enregistrer dans les propriétés unecommande clavier. Par exemple:



Ces opérations de configuration permettent d'affecter une combinaison de touches à tous les boutonsutilisés pour la fenêtre de courbes ou la fenêtre de tableaux. Il faut donc définir en plus une touchepour les fenêtres de courbes et de tableaux.Dans la fenêtre de courbes, les touches standard suivantes peuvent être utilisées après activation de latouche de fonction correspondante:


Ligne de lecture Touches de sens Déplacer la ligne de lecture versla gauche ou vers la droite

Zoom Sélectionner section pourzoom

Régler le mode de saisiealternatif à la souris et l'activer(voir paramétrage système)

La touche INS et les touches desens permettent de définir lasection pour le zoom

Dialogues p. ex.sélection de variablesd'archive

Touche Tab Pour déplacement entre leschamps de saisie

Touches de sens Déplacement de sélection devariables ou de sélectiond'onglets;

Touche + (Touche) Affichage ou fermeture del'arbre des variables d'archive;

Touche Espacement Sélection ou annulation desélection

Touche ENTREE Validation et fermeture de boîtede dialogue

Touche Echap. Interrompre boîte de dialogue.

Boutons de barre d'outils configurés de manière spécifique au process dans TagLogging

La totalité des boutons de la barre d'outils sont affichés par WinCC et ne peuvent être modifiés. Si unagencement particulier des boutons est prescrit pour le process à configurer, la barre d'outils WinCCdoit être désactivée et vous devez configurer vous-même les boutons selon les souhaits du client (p.ex. leur affecter des vues).Il faut cependant également configurer la fonctionnalité des divers boutons sous forme d'action. Dansl'action C de l'événement correspondant (p. ex. enfoncer bouton), la fonction standard associée doitêtre sélectionnée dans l'arbre des fonctions.Les fonctions proposées pour les boutons se trouvent dans les Fonctions standard taglog toolbarbuttons. A chaque bouton de la barre d'outils correspond une fonction associée dans la liste. Larègle de lecture est par exemple appelée par la fonction suivante:

Le titre de la fenêtre du contrôle Tag Logging doit être entré comme paramètre.Ces actions peuvent également être utilisées avec la souris pour commander des boutons configuréspar l'utilisateur.



3.3.10.6 Lancement de travail d’impression

Un travail d'impression peut être lancé de plusieurs manières. Vous pouvez activer l'impression dansWinCC Explorer, par emple par sélection directe dans la liste des travaux d'impression. Il estcependant possible de créer également dans la vue de process un bouton pour lancer le travaild'impression.Pour les listes d'alarmes, ce bouton existe déjà dans la barre d'outils et peut être activé par une touchede fonction ou par une touche configurée spécialement à cet effet comme décrit dans les pagesprécédentes.

Une recopie d'écran peut être activée dans chaque vue par un raccourci clavier. Cette touche deraccourci se paramètre au niveau global dans les propriétés de projet. Pour cela, appelez dans WinCCExplorer les propriétés du projet Raccourci clavier Recopie d'écran et définissez leraccourci clavier en saisissant la combinaison de touches).

Si un bouton spécial a été configuré pour lancer un travail d'impression dans la vue de process,l'impression doit être déclenchée par une action C. Comme il a été indiqué au début de ce chapitre, lebouton peut être commandé p. ex. par une touche de fonction (voir touches de raccourci clavier) oupar une commande clavier (p. ex. touche D). Vous devez par conséquent programmer l'action C pourl'événement correspondant (p. ex. clic de souris ou Clavier - Appuyer). WinCC propose cespossibilités avec les fonctions dans Fonctions standard Report ReportJob.

La fonction reçoit comme premier paramètre le nom du travail d'impression. Le deuxième paramètre àtransmettre est "PRINT" pour imprimer immédiatement ou "PREVIEW" pour afficher l'aperçu avantimpression.



3.3.10.7 Connexion ou déconnexion système

Outre les touches de raccourci configurables pour l'opération de connexion ou de déconnexion (login,logout), il est également possible de configurer une touche permettant d'appeler la boîte de dialoguede connexion. La déconnexion par touche est également possible. Il faut pour cela configurer unbouton spécifique pouvant être commandé par exemple par clic de la souris et aussi par touche clavier.La commande par touche de fonction peut également être paramétrée dans la propriété de touche deraccourci de la touche. Les différentes variantes de commande par touche sont décrites au début duprésent chapitre. La fonction devant être utilisée pour la connexion et la déconnexion est une fonctiond'application WinCC. L'emploi de cette fonction doit être configuré comme action C. Programmezl'action C par exemple sur l'événement clic de souris ou sur l'événement Appuyer sur touche.La fonction ci-dessous est utilisée pour la déconnexion:

Das Anmelden erfolgt mit der Funktion PWRTLogin().Exemple d'utilisation de ce cette fonction:

La boîte de dialogue affichée peut être commandée avec les touches standard:


Champs individuels desaisie

Touche tab (vers l’avant) ouMAJ et touche tab (versl'arrière)

Touches de sens

Déplacer la ligne de lecturevers la gauche ou vers ladroite

Validation (OK) Touche ENTREE Quitter la boîte de dialogueet valider la saisie;

Annuler Touche Echap. Annuler boîte de dialogueou saisie



3.3.11 Technique des composants de vues

La technique des composants de vue est une méthode essentielle pour la configuration rapide etsimple et pour la réutilisabilité et la bonne maintenabilité des composants de vue configurés.Une boîte de vue de process configurée sera par exemple réutilisée pour plusieurs composants deprocess semblables (p. ex. électrovannes ou régulateurs). La fenêtre de vue peut, une fois configurée,être réutilisée pour les composants de régulation à visualiser et à manipuler dans le projet, d'après lesprincipes ci-dessous:

• Copie d'une fenêtre de vue et nouvelle connexion des champs de variable

• Utilisation d'une fenêtre dont les champs de variable sont connectés à l'appel de la vue (liaisonindirecte)

• Utilisation d'objets utilisateur avec prototypes et objets créés à partir de ces prototypes

• Création de vues prototypes et liaison de ces prototypes

• Création de composants de vue OCX et liaison comme objets OCX WinCC

Comparaison des diverses techniques

Ces techniques sont très différentes quant à la manière de les utiliser, la complexité de leurconfiguration et leurs possibilités fonctionnelles; nous commencerons par conséquent par unecomparaison des diverses possibilités.

Type Avantage Inconvénient

Copie de fenêtres Simplicité toutes les liaisons d'objetsdoivent être modifiées

les modifications apportées à laconstruction des vues entraînentdes adaptations lourdes

Fenêtres de vue àliaison indirecte

• fenêtre construite une seule foisavec des actions C simples

• réutilisation sans copie de lafenêtre type

les modifications apportées à laconstruction des vues entraînentdes adaptations lourdes

Objets utilisateur Construction de l'objet ensuiteréutilisé avec liaison par assistants

• les modifications dans laconstruction de la vueentraînent des adaptationslourdes, c'est-à-dire unenouvelle création de vue

• pas de modificationcentralisée possible

Vues prototypes • Objet construit une seule fois

• modification centraliséepossible

(bonnes) connaissances de Cnécessaires

OCX • faciles à lier dans laconfiguration de WinCC commeobjet dans une vue

• Une modification ultérieure del'objet OCX ne nécessite aucunemodification des objets crééssauf si vous modifiez lespropriétés de l'objet.

• méthode très performante

• autres possibilités graphiques

doivent être créés parprogrammation (C++,VB 5); nepeuvent être créés parconfiguration WinCC.



Si seulement quelques composants de vue simples sont utilisés dans le projet, une des premièresvariantes suffira au technicien de configuration. Celles-ci peuvent être utilisées sans grande initiation.L'objet utilisateur s'avère particulièrement bien adapté aux objets simples de faible et moyennecomplexité et à la liaison à des variables. Si cet objet nécessite plusieurs modifications ultérieuresprévisibles, une initiation au concept de prototype de vue sera rentable.Lorsque les composants graphiques sont complexes ou lorsqu'une puissance de traitement importanteest nécessaire, la technique des OCX sera recommandée. Les objets OCX disponibles seront de plusen plus nombreux à l'avenir pour les divers métiers.Nous exposerons ci-dessous les principaux types de configuration de composants de vue et leurutilisation dans les vues de process. Vous pouvez ainsi vous faire une idée des différentes variantesdisponibles et de leurs domaines d'application dans vos projets.

3.3.11.1 Boîtes d'information de process comme composant de vues

Des boîtes d'information spécifiques sont incrustées dans les vues de process pour représenter les étatscourants d'un composant de process (régulateurs, électrovannes, moteurs, etc.) ou pour saisir desvaleurs de consigne. Ces boîtes de process contiennent typiquement à la fois les états courants (valeursréelles) et les valeurs de consigne saisies par l'opérateur responsable.

Création d'une boîte d'information

Cette boîte d'information se crée sous la forme d'une fenêtre dont les composants sont connectés auxvariables (de process).

Etape Type Configuration

1 Datenstrukturen Définissez dans le composant de vue les structures àemployer dans la gestion des variables, p. ex. moteuravec valeur réelle, valeur de consigne, commutateurmarche/arrêt.

2 Composant de vue Configurez dans Graphics Designer une vue affichantles états du composant de process, p. ex. de bargrapheset des champs d'E/S, ainsi que des boutons. La taille dela fenêtre (Propriété objet de vue - Dimension X etDimension Y) doit correspondre aux dimensions àobtenir pour la fenêtre de vue.

3 Définition de variables Définissez les variables (de process) dans la gestiondes variables; p. ex. moteur_T01 du type "Type demoteur", qui seront utilisées dans la boîte de process.

4 Variablenverbindung Dynamisez maintenant les composants de vue, p. ex.champs d'E/S, bargraphes, etc., par création de liaisonsaux variables (de process).

5 Fenêtre de vue Créez un objet de fenêtre dans la vue de process etconnectez cet objet au contenu de fenêtre configuré parles opérations 2 à 4 via la propriété Nom de fenêtre devue.

6 Paramétrage despropriétés

L'objet de fenêtre ne doit pas encore être affiché àl'affichage de la vue. La propriété Affichage doit êtrepar conséquent paramétrée sur Non de manièrestatique.

Il faut encore définir l'aspect de la fenêtre avec sesboutons Windows ainsi que le titre, etc. dans lespropriétés de la fenêtre.




7 Appel de la fenêtre Cette fenêtre doit être p. ex. affichée par activationd'un bouton ou par manipulation du composant deprocess lui-même. Configurez un bouton qui seraconnecté à l'affichage de l'objet de fenêtre (par liaisondirecte p. ex.)

et objet de fenêtre, le contenu de la fenêtre et l'élément de commande (bouton) servant à l'appel de lafenêtre peuvent être réutilisés sous une forme semblable pour d'autres composants de process. Il fautpour cela copier l'objet de fenêtre, le composant de vue et le bouton. Les références doivent êtreadaptées. Pour la copie, l'objet de fenêtre et le bouton peuvent être placés dans la bibliothèquegraphique (p. ex. bibliothèque de projet) à l'aide du 'Glisser-Déposer'.

Adaptation des composants de vue

Les opérations suivantes doivent par conséquent être effectuées pour l'utilisation du composant de vuecréé:


1 Prozeßvariablen Définissez une nouvelle variable de process, p. ex.moteur_T02 pour la structure définie.

2 Copie ducomposant de vue

Créez une copie du contenu de la fenêtre de vue(Moteur02.PDL) et modifiez toutes les référencesenregistrées de manière fixe (p. ex. à la place de Valeurréelle.Moteur_T01 Valeur réelle.Moteur_T02).

3 Copie de la fenêtre Créez une copie de l'objet fenêtre dans la vue de processcible (par Glisser-Déposer depuis la bibliothèquegraphique). Adaptez la référence au contenu de la fenêtrede vue dans la propriété Nom de vue(Motor02.PDL).

4 Copie du bouton Créez une copie du bouton dans la vue de process cible(par Glisser-Déposer depuis la bibliothèque graphique).Adaptez la référence au nouvel objet de fenêtre de vuedans la liaison logique (Objet ´ Fenêtre de vue2Áffichage).

e cette manière, les fenêtres d'une vue et leur contenu peuvent être créés pour chaque composant deprocess et réutilisés par simple copie. Comme on le voit, le travail à effectuer consiste à adapter lesréférences enregistrées, pour le contenu de fenêtre par exemple. Il est pour cette raison possible deréaliser plus simplement la réutilisabilité par l'adressage indirect. Le travail d'adaptation doit êtreréduit au minimum.Alternative: le composant de vue peut être également configuré sans liaison à une fenêtre de vue. Celasignifie que le composant de vue est configuré comme objet non affichable dans la vue de process.Ceci présente cependant l'inconvénient considérable, pour la modification du composant, qu'unemodification doit être effectuée dans toutes les vues utilisant ce composant de vue.



3.3.11.2 Composant de vue à adressage indirect

Jusqu'alors, les divers éléments du composant de vue étaient connectés aux variables (de process)correspondantes. Le composant conçu peut être utilisé de manière beaucoup plus souple si laconnexion est déterminée dynamiquement au runtime et non pas par une configuration fixe. Cetteliaison dynamique aux variables (de process) est réalisée par adressage indirect des divers éléments ducomposant de vue. Cela signifie que la liaison aux variables (de process) n'est pas établie directement,mais via le conteneur qui portera le nom courant de la variable (de process) correspondante auruntime.Le caractère adaptatif et réutilisable d'un composant peut être ainsi considérablement simplifié.La configuration s'effectue de manière analogue à la procédure décrite préalablement. Les étapes sontles suivantes:


1 Définition desdonnées

Définissez dans la gestion des variables les données àutiliser dans le composant de vue, p. ex. Moteur001_ Valeurréelle, Moteur001_Valeur de consigne,Moteur001_Interrupteur, d'une part, et définissez desconteneurs de nom pour les divers éléments à utiliser dansle composant de vue, p. ex. Nom_Valréelle, Nom_Valcons,etc. d'autre part. Ces variables s'initialisent avec un nom, p.ex. Moteur001_Valcons.

2 Composant devue

Configurez dans Graphics Designer une vue affichant lesétats du composant de process, p. ex. de bargraphes et deschamps d'E/S, ainsi que des boutons. La taille de la fenêtre(Propriété objet de vue - Dimension X et Dimension Y) doitcorrespondre aux dimensions à obtenir pour la fenêtre devue.

3 Liaison auxvariables

Dynamisez maintenant les composants de vue, p. ex.champs d'E/S, bargraphes, etc., par création de liaisons auxvariables des conteneurs qui contiennent les noms desvariables associées. A la connexion, il faut indiquer que lavariable n'est que le nom de la variable (de process)proprement dite. C'est pourquoi vous devez faire une croixdans la colonne pour Adr.indir. .

4 Fenêtre de vue Créez un objet de fenêtre dans la vue de process et liez cetobjet au contenu de fenêtre configuré par les opérations 2 à3 via la propriété Nom de fenêtre de vue.

5 Paramétrage despropriétés

L'objet de fenêtre ne doit pas être encore affiché àl'affichage de la vue. La propriété Affichage doit être parconséquent paramétrée sur Non de manière statique.

Il faut encore définir l'aspect de la fenêtre avec ses boutonsWindows ainsi que le titre, etc. dans les propriétés de lafenêtre.

6 Appel de lafenêtre

Cette fenêtre doit être p. ex. affichée par activation d'unbouton ou par manipulation du composant de process lui-même. Configurez un bouton qui sera lié à l'incrustation del'objet de fenêtre (par liaison directe p. ex.).

7 Bibliothèquegraphique

L'objet de fenêtre et le bouton de commande peuvent êtreplacés dans la bibliothèque à l'aide du Glisser-Déposer pourréutilisation.



3.3.11.3 bjets utilisateur

Des composants de vue facilement réutilisables peuvent être créés à l'aide d'objets utilisateur et desassistants Dynamic-Wizard. La copie du composant de vue créée peut être liée, par configurationsimple avec l'assistant, aux variables (de process) courantes associées.Un objet utilisateur est un objet graphique créé (par un concepteur, p. ex. combinaison de plusieursobjets) dont les nombreuses propriétés et les événements sont limités aux propriétés et événementsprincipaux dans un dialogue de configuration. Cet objet utilisateur est dynamisé comme prototype àl'aide de l'assistant correspondant.La séquence opératoire est la suivante:


1 Datenstrukturen Définissez dans la gestion des variables les structures àemployer dans le composant de vue.

2 Composant de vue Configurez dans Graphics Designer un objet utilisateurayant les propriétés personnalisées par l'utilisateur

ous devez créer un objet utilisateur à partir d'un groupe d'objets WinCC. Pour le moment, aucunedynamisation n'est configurée pour ces objets. Sélectionnez tous les objets devant être regroupés dansl'objet utilisateur et appelez le dialogue de configuration de l'objet utilisateur.Dans ce dialogue, toutes les propriétés des objets sont déclarées être des propriétés de l'objetutilisateur, qui seront plus tard dynamisées. Les propriétés de base d'un objet (p. ex. position et taille)ont déjà été définies pour l'objet utilisateur.Chacune des propriétés des objets regroupés peut être sélectionnée dans le dialogue et ajoutée parGlisser-Déposer au nouvel objet utilisateur comme propriété ou événement défini par l'utilisateur.Un nouveau nom d'attribut (indépendant de la langue) et le nom de propriété (fonction de la langue, p.ex. configuration en anglais) peuvent être attribués par l'utilisateur à chacune de ces propriétés. Cecipermet de n'afficher qu'un faible nombre de propriétés et d'événements (à dynamiser). Ceci permet dene montrer qu'un faible nombre seulement de propriétés et d'événements (à dynamiser). Toutes lesautres propriétés et tous les autres événements seront cachés.L'objet utilisateur créé doit être maintenant dynamisé. Un assistant est pour cela disponible:


3 Dynamisation Appelez l'assistant Dynamic-Wizard Dynamisation prototype.

Connectez chaque propriété prototypique de l'objet au champcorrespondant de la structure définie.

Le champ de structure est sélectionné pour la connexion avecle browser de variables.

L'assistant enregistre cependant uniquement le nom du champde la structure pour la propriété connectée (p. ex. 'value').Chaque propriété doit être liée séparément.

Cet objet est maintenant un objet dynamisé mais qui n'a étéconnecté qu'à un patron (prototype) et qui n'a pas encore devie au runtime. Il ne peut par conséquent pas être rafraîchi auruntime.

4 Ablegen in dieGrafikbibliothek

Rangez ce prototype comme objet dans la bibliothèquegraphique

'objet utilisateur prototypique est rangé dans la bibliothèque graphique p. ex. pour une réutilisationmultiple. Les instruments ou indicateurs à index de la bibliothèque WinCC (bibliothèque utilisateur,objets utilisateur, instruments à index) sont un exemple d'objets dynamiques.L'objet prototype est copié dans la vue de process cible. Cette copie doit cependant être maintenantliée aux variables (de process) réelles de la gestion des variables.




5 Variable Définissez pour la structure définie par l'opération 1 une variable (deprocess) devant être utilisée pour l'objet utilisateur.

6 Créeruneinstance

Créez une copie de l'objet prototype dans la vue de process parGlisser-Déposer depuis la bibliothèque graphique.

Liez cet objet à la variable (de process) avec l'assistant Instancierprototype:

L'assistant connecte automatiquement tous les champs nécessaires dela structure à la propriété correspondante du composant de vueprototypique en remplaçant, pour toutes les propriétés, chaqueliaison prototypique à une variable par la liaison concrète à unevariable.

Vous avez maintenant créé un objet qui pourra être rafraîchi auruntime avec les valeurs courantes des variables.

3.3.11.4 istance dynamique

Outre l'assistant dynamique Instanciation statique de prototype, il existe également un assistantd'instanciation dynamique de prototype. Quelle est la différence par rapport à l'instanciation statiqueet quelles opérations doivent être modifiées ?A la différence de la liaison statique d'un objet à des variables, les composants de vue peuvent êtreaussi connectés dynamiquement. Cela signifie que l'instance ne sera activée au runtime qu'en fonctiondu contenu courant d'une variable. Par exemple, le composant décrit ci-dessus ne sera pas liéstatiquement à la variable, mais le nom de la variable sera dynamiquement géré. Le nom courant de lavariable doit alors être recherché via une variable de texte. Cette variable de texte, qui contient le nomcourant d'une variable, doit être liée au composant de vue.A la différence de l'instanciation statique, les opérations suivantes doivent être modifiées à laconfiguration:


1 Composant de vue Configurez dans Graphics Designer un objet utilisateurayant les propriétés définies par l'utilisateur comme décritci-dessus. L'objet utilisateur doit contenir un composantde texte statique dont la propriété texte sera reprisecomme composant défini par l'utilisateur.

Cette propriété Texte reçoit le nom d'attribut Tagname. Cenom de variable est utilisé pour la liaison dynamique desvariables (de process).

2 Variable Définissez pour la structure définie par l'opération 1 unevariable (de process) devant être utilisée pour l'objetutilisateur.

3 Créez une instance Créez une copie de l'objet prototype dans la vue deprocess par Glisser-Déposer depuis la bibliothèquegraphique.

Liez cet objet à la variable (de process) avec l'assistantInstancier prototype:

L'assistant connecte automatiquement tous les champsnécessaires de la structure aux propriétés respectives ducomposant de vue prototypique en remplaçant, pour toutesles propriétés, chaque liaison à une variable prototypiquepar la liaison à une variable concrète.

Vous avez maintenant créé un objet qui pourra êtrerafraîchi au runtime avec les valeurs courantes desvariables.



Lrs de l'utilisation des objets utilisateur et des prototypes dynamisés, le concepteur s'assurera que lesactions C nécessaires sont bien déjà enregistrées pour les objets. Celles-ci ne doivent pas être effacées,faute de quoi l'ensemble de la fonctionnalité du composant serait perdu.

3.3.11.5 Vues prototypes

La technique des vues prototypes va encore un peu plus loin. Le concept d'utilisation du prototypepeut être organisé de manière si souple que toute modification d'un prototype se répercuteautomatiquement sur les objets créés. Cette souplesse nécessite des scripts C très flexibles qui doiventêtre liés.La technique des vues prototypes utilise des 'modèles' de vues pouvant être liés plusieurs fois à une ouplusieurs vues mère. Une vue modèle est simplement un 'patron' qui ne sera activé que dans un objetréel. La création d'un objet à partir d'un modèle (=vue prototype= patron) se fait par instanciation.Plusieurs instances (c.-à-d. objets réels concrets) peuvent être créées à partir d'un même modèle.

Modèle de fenêtre

Fenêtres utilisées avec données courantes du gestionnaire de données.

Les modifications ultérieures se font de manière centralisée (dans le prototype) et sont répercutées surtoutes les applications (instances). Ceci est une technique très efficace qui permet de faire l'économied'adaptations laborieuses dans toutes les applications.Il est possible d'afficher jusqu'à 30 instances (objets) d'un type de modèle dans une vue mère. Il estégalement possible d'utiliser plus de 30 objets en recourant à divers prototypes.Les vues prototypes sont des composants de vue qui sont rangés, après leur création, dans labibliothèque pour être réutilisés. Les composants de vue sont utilisés comme des instances de modèledans les vues de process. Ces copies affichent les données courantes, p. ex. de régulateurs ou demoteurs, qui sont visualisées dans le composant de vue. Les composants de régulateur ou de moteurcorrespondants sont affichés automatiquement.Il est possible de créer des composants de vue simples ou complexes. Un composant de vue peut êtrecomposé de plusieurs éléments. Ceux-ci se recouvrent en tout ou partie mais forment une entitécohérente. Par exemple, toutes les données d'un moteur, telles que la vue de son état actuel, lesdonnées d'évolution du process, les données de maintenance, etc., sont regroupées dans un objet etrafraîchies en cas de besoin. Lorsque le process comporte de nombreux moteurs du même type, ilsuffit de faire des copies après avoir créé le composant de vue. Tout le reste est automatique.La séquence ci-dessous est nécessaire pour la création:




1 Structures de données Définissez dans la gestion des variables lesstructures à utiliser dans le composant.

2 Construction de fenêtre de vue Configurez dans Graphics Designer lecontenu du composant de vue, p. ex.bargraphes, champs d'E/S, etc.

3 Connectez les structures à lafenêtre de vue

Connectez les composants de vue aux champsde la structure à l'aide de scripts C spéciaux(tirés de l'exemple de projet).

4 Fenêtre de vue Liez le composant de vue à l'objet de fenêtrede vue

5 Bibliothèque graphique Placez la fenêtre dans la bibliothèquegraphique

Le composant de vue peut être maintenant réutilisé dans les vues de process en le sélectionnant dansla bibliothèque graphique.Examinons tout d'abord la création du modèle (Template).

Etape Configuration

1 Création d'une structure (type de données, type de structure) dans le gestionnairede données: vous définissez ici le nombre de variables élémentaires (champs) quiconstitueront la structure, leurs noms et leurs types respectifs (BIT, SHORT,WORD, TEXT, etc.). p. ex. PID avec valeur de consigne, valeur mesurée ettempérature comme champs d'une structure.

2 Création d'une vue à utiliser comme modèle. Cette vue est typiquement pluspetite que l'écran et peut être redimensionnée. Chaque vue créée peut être utiliséepour constituer un modèle (Template).

La vue est créée à l'aide des fonctions graphiques d'édition; des variablesgraphiques, telles que les champs E/S, les bargraphes, les indicateurs d'états, etc.,y sont placées mais ne sont pas liées à des variables.

Des relations internes (liaisons directes) entre objets graphiques, comme p. ex. lepassage de la valeur de sortie d'un champ d'E/S à un bargraphe, déclenché parmodification de valeur de variables, sont configurées dans la vue.

3 Les champs graphiques sont maintenant liés aux champs correspondants de lastructure. Cette configuration de liaison crée des connexions au niveau des types(uniquement au niveau prototype) et ne connecte pas encore les champs desstructures à des objets concrets du process.

Il existe pour cela un exemple de projet préparé sur le CD WinCC (\Samples).

La bibliothèque de projets (\Template) de ce projet contient un objet utilisateurTemplateInit qui effectue les connexions entre champs de structures. Il se trouvedans la bibliothèque graphique et peut en être extrait et placé par Glisser-Déposerdans une vue à concrétiser.

L’objet TemplateInit possède déjà une logique de scripts toute prête. Cettelogique utilise une table de connexions que vous remplissez à la configuration etqui contient exactement les entrées soulignées ci-dessus. La connexion entre lespropriétés et les champs de la structure est ainsi effectuée.

L'établissement de ces connexions peut être activé à l'intérieur d'un modèle ou del'extérieur. Il existe dans la bibliothèque graphique de projets spécifique desobjets utilisateur qui ont l'aspect extérieur de boutons, mais qui gèrent desinformations paramétrables via le modèle (template) à invoquer.

Tous les scripts servant à réaliser ces prototypes prêts à l'emploi doivent êtrechargés dans le projet cible. Voir à ce sujet les dernières opérations 8-10 à la findu chapitre. Les prototypes ne sont pas réalisables sans ces fonctions de projet.



Etape Configuration

4 Cette vue doit être utilisée comme boîte de process.

Créez pour cela dans une vue temporaire (qui n'est nécessaire que pour cetteétape intermédiaire) un objet fenêtre de vue et liez la propriété Nom de vue de cetobjet à la vue contenant le composant de vue.

5 Placez cet objet de fenêtre de vue dans la bibliothèque graphique par un 'Glisser-déposer'.

Ce modèle peut être maintenant réutilisé plusieurs fois dans les vues de process. La liaison auxvariables de process s'effectue automatiquement par les noms attribués.


6 Définition de variables Définissez une variable (de process) pour le type dedonnnées associé (p. ex. PID_1 du type PID).

7 Créer une instance Copiez le composant de fenêtre de vue depuis labibliothèque graphique

Attribuez immédiatement le nom d'objet de la fenêtrede vue au nom de la variable (de process) à utiliser (p.ex. PID_1): attribuez à Objet de fenêtre de vue

Fenêtre de vue Nom d'objet Statique GG la valeur PID_1

orsque vous placez le composant de vue, il reçoit le nom d'une variable (de process) structurée dontles champs contiennent les données d'état d'un objet de process. Au runtime, le composant de vue seprocure automatiquement les données d'état.Ces vues prototypes utilisent certains scripts C qui sont ou ont été enregistrés comme fonctions deprojet. Pour pouvoir utiliser les scripts C préparés, les scripts ci-dessous doivent être repris del'exemple de projet. Procédez de la manière suivante:


8 Copie desfichiers defonctions

Copiez depuis le projet exemple, chemin

9 Déclarezcesfonctionsau projet

pour déclarer les nouvelles fonctions, appelez dans WinCC

l'éditeur Global Script via (Global Script D Ouvrir).

Vous pouvez maintenant, à l'aide du bouton Générer en-tête,déclarer les nouvelles fonctions dans l'arborescence des fonctionsdu projet. Les nouvelles fonctions sont alors visibles dans la listedes fonctions de projet.




10 Reprised’objetsutilisateur

Les objets utilisateur sont disponibles dans la bibliothèque deprojet. Dans un nouveau projet pour lequel vous n'avez pas encoreenregistré de symboles spécifiques dans la bibliothèque, vouspouvez simplement copier la bibliothèque depuis l'exemple deprojet dans votre projet:

dans votre cheminCopier \Library !

Sinon, vous pouvez transférer les objets utilisateur d'un projet àl'autre à l'aide du mécanisme d'exportation:

Exportez les symboles souhaités dans votre projet exemple sousforme de fichiers .emf (Fichier → Exportation) et importez cessymboles .emf dans une vue temporaire de votre projet par lescommandes Coller → Importation. Transférez les symbolesdans votre bibliothèque de projet à l'aide de la fonction 'Glisser-déposer'. Utilisez pour cela un dossier spécifique p. ex. 'Template'.

es composants de vue (de vues concrétisées ou modèles) permettent des économies de ressourcesimportantes. Ils sont modélisés comme objets référencés à des variables et rangés p. ex. dans labibliothèque graphique. Ils sont extraits de la bibliothèque graphique, placés dans la vue de process etalimentés automatiquement en données au runtime. La configuration de liaisons de variables à deséléments de graphisme tels que champs d'E/S, bargraphes, etc., n'est plus nécessaire.Lorsque ces vues prototypes sont utilisées, il existe plusieurs manières d'affecter le nom courant àl'élément du composant de vue. Ceci s'effectue à l'aide des variables ci-dessous, que nous nommeronsbrièvement:

• Le nom d'instance est déterminé automatiquement à la sélection de la fenêtre de vue: pour cela unefonction de projet fournie par le système (EnabelTemplateInstance) est mémorisée dans la fenêtrede vue pour l'événement 'Sélection de vue'.

• Vous définissez le nom d'instance par une variable E/S qui est automatiquement lue par un scriptdans la fenêtre de vue pour déterminer le nom de l'instance; on utilise pour cela l'objet utilisateurpréconfiguré InstanceCallButton+Template.

• Un bouton passe le nom d'instance directement à la fenêtre de vue appelée:On utilise pour celal'objet utilisateur préconfiguré InstanceCallButtons+Template.

Des exemples détaillés sont donnés pour ces variantes dans l'exemple de projet fourni sur le CDWinCC (\Samples).

3.3.11.6 Objets OCX

Les objets OCX et ActiveX sont des composants de vue disponibles sous forme exécutable. Certainsde ces composants (contrôles) sont proposés en standard par WinCC, p. ex. le contrôle d'horlogenumérique/analogique WinCC.Ces composants peuvent être intégrés de manière simple aux vues de process.


1 Intégrer un objetOCX

Sélectionnez dans la palette d'objets de Graphics Designerle type d'objets Contrôle OLE (OCX) parmi les objetscomplexes. Dans la vue de process, agrandissez l’objet en

maintenant enfoncé et sélectionnez l'élément souhaitédans la boîte de dialogue ensuite affichée.

2 Lier propriétés L'objet intégré possède également des propriétés et desévénements. Les propriétés et événements disponiblespour un objet dépendent de l'OCX spécifique.

Vous pouvez p. ex. créer une liaison à une variable avec lapropriété Couplage process. werden.



Céation

Les composants de vue OCX doivent être créés avec un AGL spécial. Ce environnement peut être p.ex. Visual C++ 5 ou Visual Basic 5 de Microsoft.Les composants peuvent ainsi être modifiés ou affinés. Ils sont très performants, mais ne peuvent pasêtre créés avec un atelier de génie logiciel WinCC. Les composants OCX doivent toujours être créésou modifiés en externe.Par contre, la technologie des vues prototypes ne nécessite que des moyens propres à WinCC. Il n'estalors pas nécessaire de posséder un savoir-faire en programmation d'OCX.Un grand nombre de ces composants sont déjà disponibles aujourd'hui. Des 'Faceplates PCS7' prêts àl'emploi sont maintenant proposés dans le cadre de l'intégration de la supervision de process et de laprogrammation d'automates programmables (PCS7).

Enregistrement

Les composants OCX créés ou du commerce doivent être enregistrés sur la station WinCC. Il estpossible de voir dans le dialogue de sélection, dans Graphics Designer (voir description ci-dessus),quels objets OCX sont disponibles sur une station WinCC. Tous les composants OCX enregistrés surune machine sont listés dans le dialogue. Un composant OCX s'enregistre sous forme d'un fichierayant l'extension .OCX ou .dll.Lorsqu'un composant n'a pas encore été enregistré, ceci peut être effectué dans le dialogue decontrôles OLE de WinCC. Cette boîte de dialogue contient un bouton pour l'enregistrement et pour lasuppression de l'enregistrement des composants sélectionnés.Pour la procédure d'enregistrement, le fichier correspondant doit se trouver sur la station WinCC.La compatibilité et le bon fonctionnement des composants OCX doivent être testés par le concepteur.Seuls les composants OCX marqués WinCC ont été utilisés et testés dans l'environnement WinCC.



3.3.12 Configuration en ligne (runtime) - Remarques, restrictions

Un certain nombre de points sont à respecter pour la configuration en ligne.Pour diverses raisons, quelques rares modifications ne peuvent pas être effectuées pendant laconnexion au process ou seulement dans certaines conditions; il arrive également que lesmodifications ne deviennent actives qu'ultérieurement.

Explorateur WinCC

• Les modifications ci-dessous ne sont pas prises en compte

• Modification du type d'un ordinateur dans la liste d'ordinateursLes opérations de programmation ci-dessous ne sont pas possibles au runtime:

• Suppression/Renommage de variables

• Modification du type d'une variable

Alarm Logging

Les modifications ci-dessous ne sont pas prises en compte

• Modification des archives / journaux

• Modification des alarmes groupées

• Toute alarme groupée contenant au total plus de 500 alarmes individuelles au runtimeLes opérations de programmation ci-dessous ne sont pas possibles au runtime:

• Aucune restriction

Tag Logging



Les opérations de programmation ci-dessous ne sont pas possibles au runtime:

• Les tableaux des archives utilisateur peuvent être créés mais pas modifiés.

• La suppression de données dans Tag Logging et dans les archives utilisateur.Exception pour la configuration au runtime:Les tables des archives utilisateur peuvent être éditées et supprimées via l'API de runtime de TagLogging.

Global Script


• La modification d'un script d'assistant n'est validée qu'au relancement de l'éditeur GraphicsDesigner.

• Scripts d'assistants modifiés.Les opérations de programmation ci-dessous ne sont pas possibles au runtime:




Report Designer


• Modification du journal au fil de l'eau, étant donné que ce journal d'enregistrementschronologiques, une fois lancé, reste actif en permanence au runtime et ne recharge pas lesinformations de modèles de page et de modèles de ligne.



Redundancy


• Le nom d'ordinateur du partenaire ne peut être commuté sur un ordinateur tiers.

• L'aiguilleur AutoSwitcher ne peut être modifié: il faut configurer dès le début la cible vers laquelledoit se faire l'aiguillage. Il annule cependant le basculement en cas de panne du partenaire.



SIMATIC S7 Suite de protocoles ou canal S/7PMC


• Les paramètres de diagnostic avec le composant S7Chn.ini (pas édité) ne sont pas pris comptependant la connexion au process.

Toutes les modifications d'adresses de communication sont certes prises en compte en ligne, maiselles ne sont exploitées que lors de l'établissement d'une liaison.Les opérations de programmation ci-dessous ne sont pas possibles au runtime:


Text Library



• Dans Text Library, les textes modifiés sont repris par les commandes de menu FichierEnvoyer modifications au projet actif

• Dans Alarm Logging, les modifications de la bibliothèque de textes sont reprises par Fichier Enregistrer.



User Administrator

Les modifications ci-dessous ne sont pas prises en compteLes modifications des autorisations d'accès des utilisateurs ne sont activées qu'après une nouvelleconnexion ou déconnexion.Les opérations de programmation ci-dessous ne sont pas possibles au runtime:


09.99 Cours de programmation en C


4 Cours de programmation en CWinCC offre plusieurs moyens de dynamiser des objets. Il s’agit entre autres des liaisons à desvariables, des dialogues de dynamisation et des liaisons directes. Ces moyens de programmationpermettent de réaliser des dynamisations complexes. Malgré cela, les exigences croissantes font qu'ilsatteignent leurs limites. La configuration d'actions C, de fonctions de projet et d'actions offre àl'utilisateur un éventail de possibilités bien plus large. Ces moyens doivent être créés dans le langagede scripts C de WinCC. Pour de nombreuses applications il n'est pas nécessaire de posséder deconnaissances approfondies du C. Il suffit de paramétrer des fonctions existantes. Quelquesconnaissances de base du langage C sont cependant nécessaires pour pouvoir utiliser pleinement sespotentialités comme langage de scripts WinCC. Ce cours est destiné à vous apporter cesconnaissances.

Cible du cours

Ce cours doit apporter les connaissances de base de l'utilisation générale du C à tous ceux qui ne sontpas familiers de ce langage de programmation. Aux programmeurs en C expérimentés, il feradécouvrir les particularités de l'emploi de C dans WinCC.Il n'est pas possible de copier le projet exemple de ce cours directement du document Online sur votredisque dur. Il est rangé par défaut dans le répertoire C:\Communication_Manual.

Project_C_Course

Cours de programmation en C 09.99


Projet exemple

L'interface utilisateur du projet exemple est organisée en plusieurs éléments. Ce sont:

• la barre de navigation (1): Elle permet de sélectionner les vues affectées aux divers chapitres.

• Fenêtre de chapitre (2): La fenêtre de chapitre affiche les vues affectées aux divers chapitres. Cesvues contiennent tous les exemples décrits dans les divers chapitres. La plupart des exemples sontcréés pour être manipulés par des boutons.

• Fenêtre de scripts(3): La fenêtre de scripts affiche le code de l'exemple sélectionné dans lafenêtre de chapitre. L'exemple courant est marqué en rouge dans la fenêtre de chapitre.

• Fenêtre de diagnostic (4): La fenêtre de diagnostic affiche les sorties des divers exemples par lafonction printf().



4.1 Environnement de dveloppement de scripts C

Deux éditeurs sont disponibles pour la création de scripts en C dans WinCC. Il s'agit d'une part del'éditeur d'actions C de Graphics Designer; d'autre part de l'éditeur Global Script pour la création defonctions de projet et d'actions globales. La syntaxe du langage de scripts est celle de l'ANSI-C.Une autre utilisation du langage de programmation C dans WinCC est la création de DynamikWizards. Il existe pour cela un éditeur spécifique. La manipulation de cet éditeur sera expliquée dansl'exemple Dynamik Wizard et ne sera pas traitée dans cette présentation générale.



4.1.1 Editeur d’actions de Graphics Designer

Vous pouvez, dans Graphics Designer dynamiser des propriétés d'objets par des actions C. Il estégalement possible de configurer des réactions à des événements d'objets par des actions C.

Editeur d’actions

WinCC contient un éditeur pour la configuration d'action C. Il s'ouvre dans le dialogue Propriétés

d'objet par D sur la propriété ou sur l’Evénement puis sur Action C. Les actions C déjà crééessont marquées par une flèche verte sur la propriété ou sur l’événement.

L’action C peut être programmée dans l'éditeur d'actions. Pour les actions C programmées pour despropriétés, vous devez définir un déclencheur. Ceci n'est pas nécessaire pour les actions Cprogrammées sur des événements puisque l'événement est lui-même le déclencheur. L'action Cprogrammée doit être compilée. Si la compilation se fait sans erreurs, vous pouvez quitter l'éditeurd'actions par OK.



Structure d’une action C

Une action C correspond d'une manière générale à une fonction en C. On peut distinguer deux typesd'actions C. Celles qui sont créées sur des propriétés et celles qui sont créées sur des événements. Uneaction C créée sur une propriété est en général utilisée pour piloter la valeur de cette propriété enfonction de diverses conditions environnantes (p. ex. la valeur d’une variable). Dans ce type d’actionsC, vous devez définir un déclencheur pour contrôler l'exécution. Les actions C programmées sur unévénement sont utilisées pour configurer des réactions à cet événement.

Action C pour une propriété

L'exemple de code proposé représente une action C typique pour une propriété. La signification desdifférentes parties est décrite ci-après.

• En-tête (gris): Les trois premières des lignes sur fond gris représentent l'en-tête de l'action C. Ilest généré automatiquement et ne peut pas être modifié. L'en-tête de la fonction est identique pourtoutes les propriétés sauf pour le type de la valeur retournée (dans l'exemple de code précédent, ils'agit du type long). Trois paramètres sont passés à l'action C. Il s'agit du nom de vue(lpszPictureName ), du nom d'objet (lpszObjectName ) et du nom de propriété(lpszPropertyName).

• Déclaration des variables (1): La première section de code modifiable contient les déclarations devariables. Dans l'exemple de code précédent, il s'agit d'une seule variable du type long.

• Calcul de valeur (2): La section suivante contient le calcul de la valeur de la propriété. Dansl'exemple de code ci-dessus, elle ne contient que la valeur d'une seule variable.

• Renvoi de valeur (3): La valeur calculée pour la propriété doit être affectée à la propriété. Cetteassignation se fait par l'instruction return.



Action C sur un événement

L'exemple de code proposé représente une action C typique pour un événement. La signification desdifférentes parties est décrite ci-après.

• En-tête (gris): Les trois premières des lignes sur fond gris représentent l'en-tête de l'action C. Ilest généré automatiquement et ne peut pas être modifié. L'en-tête de la fonction a une apparencedifférente pour les divers types d'événements. Vous devez passer à l'action C les paramètreslpszPictureName (nom de vue), lpszObjectName (nom d'objet) et lpszPropertyName (nom depropriété). Le paramètre lpszPropertyName ne contient cependant des données pertinentes quepour les événements qui réagissent à la modification de propriétés. Il est également possible depasser d'autres paramètres spécifiques à l'événement.

• Déclaration des variables (1): La première section de code modifiable contient les déclarations devariables. Dans l'exemple de code précédent, il s'agit d'une seule variable du type long.

• Traitement de l'événement (2) : La section suivante contient l'exécution d'actions quicommanderont la réaction du système à l'événement. L'exemple de code ci-dessus contient lavaleur d'une variable WinCC. Cette valeur est affectée comme Position X à l'objet. La valeurretournée par une action C programmée sur un événement est du type void: le programme n'attendpas de valeur retournée.



Création d'une action C

Le tableau ci-dessus présente les étapes nécessaires à la création d'une action C.

Etape Procédure: Création d'une action C

1 Ouvrez l'éditeur Graphics Designer.

Ouvrez la vue WinCC souhaitée.

Ouvrez le dialogue Propriétés de l'objet souhaité.

2Pour la propriété ou l'événement souhaité, ouvrez via D et Action C l'éditeurEditer action.

3 L'éditeur Editer action est affiché.

Il contient déjà une fonction maquette.

L'en-tête de l'action C a entre autres été généré automatiquement. Il ne peut plusêtre modifié.

La première ligne de l'en-tête de l'action C intègre le fichier apdefap.h à l'action.Ce fichier déclare à l'action C toutes les fonctions de projet, les fonctionsstandard et les fonctions internes.

La deuxième partie de l'en-tête de l'action C est l'en-tête de la fonction. Ellerenseigne sur la valeur retournée par l'action C et sur les paramètres transmispouvant être utilisés dans l'action C. La troisième partie de l'en-tête de l'action Cest l'accolade ouvrante. Elle ne peut être supprimée. Entre celle-ci et l'accoladefermante déjà présente se trouve le code à proprement parler de l'action C.

4 Une autre section de code générée automatiquement est composée de deux blocsde commentaires. Ils sont nécessaires pour permettre à l'éditeur d'accéder par lecomposant CrossReference aux informations internes d’une action C. Ils sontnécessaires pour la réaffectation également à l'intérieur d'une action C. Vouspouvez supprimer sans problème ces commentaires s'ils ne doivent pas êtreutilisés. Le premier bloc de commentaire définit les variables WinCC utiliséesdans l'action C. Vous devez alors utiliser le nom défini pour la variable à la placede son nom réel dans le code.

Le deuxième bloc de commentaire définit les vues WinCC utilisées dans l'actionC. Vous devez alors aussi utiliser pour les vues le nom défini à la place du nomréel dans le code.

Un exemple de code pour ce thème est proposé à la suite de ce tableau. Il montrela définition d'une variable WinCC et d'une vue WinCC ainsi que l'utilisation quiest faite de ces définitions.




5 Programmation du corps de fonction, qui exécute les calculs, actions, etc.

Vous disposez de plusieurs moyens de programmation. Un d'entre eux est lasélection de variables. Pour l'ouvrir, cliquez sur le bouton de la barre d'outilsreprésenté ci-dessous. Dans le dialogue affiché Variable, sélectionnez unevariable WinCC puis validez par OK. Le nom de la variable WinCC sélectionnéeest inséré dans l'action C à la position courante du curseur.

6 Un autre moyen de programmer est la sélection de fonction dans la fenêtre degauche de l'éditeur d'actions. La sélection de fonctions permet d'insérerautomatiquement, à la position courante du curseur, toutes les fonctions de projet,les fonctions standard et les fonctions internes disponibles dans l'action C.

Pour cela, sélectionnez la fonction souhaitée par GG. Le dialogueParamétrage qui contient une liste de tous les paramètres à définir et leur type dedonnées est affiché. Vous pouvez paramétrer la fonction dans la colonne Valeur.Outre la saisie de texte, vous pouvez également utiliser les options Sélection devariables, Objets graphiques et Vues.

Pour insérer la fonction à la position courante du curseur dans l'action C, vousdevez valider le dialogue par OK.




7 L'action C programmée doit maintenant être compilée. L'enregistrement sedéclenche avec le bouton ci-dessous de la barre d'outils.

Le résultat de la compilation est affiché en bas à gauche de l'éditeur d'actions. Lenombre des erreurs survenues et le nombre des avertissements sont affichés. Leserreurs ont toujours comme conséquence que l'action C n'est pas exécutable. Lesavertissements signalent par contre des erreurs susceptibles de pouvoir seproduire lors de l'exécution de l'action C. Des actions C programmées dans unbon style doivent afficher 0 Error(s), 0 Warning(s).

Si des erreurs surviennent pendant la compilation, elles sont affichées dans la

fenêtre. Un GG sur un message d'erreur dans la fenêtre permet de basculerdirectement dans la ligne de code correspondante.

8 Vous devez définir un déclencheur pour les actions C qui ont été créées pour unepropriété d'un objet. Ceci n'est pas nécessaire pour les actions C programméessur des événements puisque l'événement est lui-même le déclencheur.

La définition du déclencheur se fait par le bouton de la barre d'outils représentéci-dessous. Vous pouvez également utiliser des déclencheurs temporels ou desdéclencheurs activés par une variable.

9 Un clic sur le bouton OK de l'éditeur d'actions ajoute l'action C programmée à lapropriété ou à l'événement souhaité. Une propriété ou un événement dynamisépar une action C est marqué d'une flèche verte.



Définition de variables et de vues WinCC

Lorsqu’une nouvelle action C est créée, elle contient une section de code générée automatiquement etcomposée de deux blocs de commentaires. Ces blocs de commentaires sont nécessaires pour permettreà l'éditeur d'accéder via le composant CrossReference aux informations internes d'une action C. Ilssont nécessaires pour la réaffectation également à l'intérieur d'une action C.

• Définition des variables: Le premier bloc de commentaire définit les variables WinCC utiliséesdans l'action C. Le bloc de commentaire commence par la ligne // WINCC:TAGNAME_SECTION_START et se termine par la ligne // WINCC: TAGNAME_SECTION_END.Entre ces deux lignes se trouvent les noms de toutes les variables WinCC utilisées dans l'action C.Une variable se définit par l'instruction de préprocesseur #define suivie du nom à définir (dansl'exemple de code précédent S32I_COURSE_TEST_1 ) „S32i_course_test_1").

• Définition des vues: Le deuxième bloc de commentaire définit les vues WinCC utilisées dansl'action C. Le bloc de commentaire commence par la ligne // WINCC:PICNAME_SECTION_START et se termine par la ligne // WINCC: PICNAME_SECTION_END.Entre ces deux lignes se trouvent les noms de toutes les vues WinCC utilisées dans l'action C. Cecise fait comme pour la définition des noms de variables.

• Utilisation: Dans le code, vous devez utiliser les alias définis à la place des noms réels desvariables et des vues. Avant la compilation de l'action C, le préprocesseur remplace tous les nomsdéfinis par les noms réels.



4.1.2 Editeur Global Script

L'éditeur Global Script sert à créer des fonctions de projet, des fonctions standard et des actions.

Fonctions de projet

Si la même fonctionnalité est fréquemment utilisée dans diverses actions C, vous pouvez la formulerdans une fonction de projet. Les fonctions de projet peuvent, comme toutes les autres fonctions, êtreappelées dans toutes les actions du projet WinCC. La liste ci-dessous présente les avantages desfonctions de projet par rapport à la création de la totalité du code par actions C.

• Modifications centralisées: toute modification de la fonction de projet est répercutée sur toutesles actions C utilisant cette fonction. Si vous n'utilisez pas de fonctions de projet, vous devezmodifier toutes les actions C concernées. Cela facilite non seulement la configuration mais aussi lamaintenance et le diagnostic d'erreurs.

• Réutilisabilité: Lorsqu’une fonction de projet a été programmée et testée, elle peut être réutilisée àtout moment sans programmation complémentaire et sans nouveaux tests.

• Réduction du volume des données de vues: Le fait de ne pas enregistrer la totalité du codedirectement dans l'action C programmée sur l'objet réduit le volume des données de vues. Il enrésulte une formation plus rapide de la vue à l'écran et de meilleures performances au runtime.

• Protection par mot de passe: Il est possible de protéger une fonction de projet contred'éventuelles modifications en attribuant un mot de passe. Cela signifie qu'il y a protection desdonnées de configuration et de votre savoir-faire.

Les fonctions de projet ne sont connues qu'en interne dans le programme. Elles se placent dans lerépertoire < Répertoire de projet WinCC >\LIBRARY et sont définies dans le fichier ap_pbib.h dumême répertoire.Vous disposez déjà d'un grand nombre de fonctions standard. A la différence des fonctions de projet,elles sont disponibles dans tous les projets WinCC. Les fonctions standard existantes peuvent êtremodifiées. Vous pouvez également créer de nouvelles fonctions standard.

Les fonctions standard ne se distinguent des fonctions de projet qu'en ce que celles-ci ne sont connuesque du projet alors que celles-la le sont de tous les projets. Les fonctions standard se placent dans lerépertoire < Répertoire d'installation WinCC >\APLIB, dans le fichier ap_glob.h du même répertoire.

Fonctions internes

Outre les fonctions de projet et les fonctions standard, il existe encore des fonctions internes. Il s'agitentre autres de fonctions C standard. Elles ne peuvent pas être modifiées par l'utilisateur et il n'est paspossible non plus de créer de nouvelles fonctions internes.

Actions

Les actions, à la différence des fonctions décrites précédemment, ne sont pas appelées dans une actionC ou dans une une autre fonction. Un déclencheur pilotant l'exécution de l'action lui est affecté. Elleest exécutée indépendamment de la vue sélectionnée au runtime.Les actions peuvent être globales, donc configurées pour l'ensemble du projet. Dans ce cas, elles sontrangées dans le répertoire < Répertoire de projet WinCC >\PAS. Vous pouvez cependant aussiconfigurer des actions locales (des actions spécifiques à un ordinateur) que vous rangez dans lerépertoire < Répertoire de projet WinCC >\NomOrdinateur\PAS.Si le Global Script Runtime est inscrit dans la liste de démarrage de l'ordinateur, toutes les actionsglobales et toutes les actions locales de l'ordinateur correspondant sont activées au démarrage duprojet.



Création d'une fonction de projet

La procédure à suivre pour créer une fonction de projet est identique à celle de création de fonctionsstandard. La description ci-dessous est donc aussi valable pour la création d'une fonction standard.

Etape Procédure: Création d'une fonction de projet

1 Ouvrez l'éditeur Global Script.

2Créez le modèle d'une nouvelle fonction de projet par les commandes DFonctions de projet et Nouveau Fonction.

3 Une fonction de projet peut être entièrement définie par l'utilisateur. Elle necomprend pas de parties de code non modifiables.

Programmation de l'en-tête d'une fonction. Vous devez attribuer à la fonction unnom par lequel elle sera appelée dans les actions C ou dans d'autres fonctions.Vous devez en outre définir la valeur retournée et les paramètres à passer pour lafonction.

Si d'autres fonctions de projet ou fonctions standard doivent être utilisées dans lafonction précédente, vous devez lier le fichier apdefap.h. Ceci se fait parl'instruction de préprocesseur #include „apdefap.h", qui doit encore être placéeavant l'en-tête de la fonction.

4 Programmation du corps de fonction.

Vous disposez pour cela des mêmes moyens que pour programmer les actions C.Il s'agit de la sélection de variables et de la sélection de fonction.



Etape Procédure: Création d'une fonction de projet

5 L'action C programmée doit maintenant être compilée. L'enregistrement sedéclenche avec le bouton de la barre d'outils affiché ci-dessous.

Le résultat de la compilation est affiché dans la fenêtre. Les erreurs et

avertissements survenus ainsi que leur nombre sont affichés. Un GG sur unmessage d'erreur dans la fenêtre permet de basculer directement dans la ligne decode correspondante.

6 Le bouton de la barre d'outils représenté ci-dessous permet d'ajouter unedescription à la fonction de projet. Il est possible, dans cette description, dedéfinir un mot de passe pour protéger la fonction de projet contre toute tentatived'accès illicite.

7 Vous devez enregistrer la fonction de projet programmée sous un nomcorrespondant.

Création d'une action globale

La procédure à suivre pour créer une action globale est identique à celle de création d'actions locales.La description ci-dessous est donc aussi valable pour la création d'une action locale.

Etape Procédure: Création d'une action globale

1 Ouvrez l'éditeur Global Script.

2Via D sur Actions globales et Nouveau Action, créez le modèle d'unenouvelle action.



Etape Procédure: Création d'une action globale

3 L'en-tête de l'action a été généré automatiquement et ne peut être modifié.

En outre, les deux blocs de commentaires sont ajoutés pour la définition desvariables et des vues WinCC. La signification de ces deux blocs de commentairesa déjà été expliquée dans la section précédente, à l'occasion de la description desactions C.

4 Programmation du corps de l'action.

Vous disposez pour cela des mêmes moyens que pour programmer les actions C.Il s'agit de la sélection de variables et de la sélection de fonction.

L'action retourne une valeur du type int. Cette valeur retournée ne peut cependantpas être exploitée par l'utilisateur. La valeur retournée par défaut est 0.

5 Le bouton de la barre d'outils représenté ci-dessous permet d'ajouter unedescription à l'action comme pour une fonction. Il est possible de définir ici unmot de passe pour protéger l'action contre toute tentative d'accès illicite.

A la différence des fonctions, vous devez configurer un déclencherur pour piloterl'action. Pour la sélection du déclencheur d'une action, l'utilisateur dispose d'uneplus large palette d'options que pour sélectionner le déclencheur d'une action Cprogrammée pour un objet. Vous pouvez entre autres configurer une exécutionqui ne sera réalisée qu'une seule fois.

6 Vous devez enregistrer l'action ainsi programmée.

Affichage des résultats du test

L'exécution d'un programme peut être suivie par l'affichage du test. Ceci facilite la localisation et lediagnostic des erreurs pendant le développement. Vous pouvez afficher les tests par la fonctionprintf(). Cette fonction affiche des textes simples, mais aussi les valeurs courantes de variables. Pourrendre les textes visibles, vous devez configurer une fenêtre de diagnostic Global Script.



La fonction printf()

La fonction printf() permet d'afficher les tests. Un exemple d'utilisation de cette fonction est proposéci-après.

La fonction printf() requiert au moins un paramètre. Il s'agit d'une chaîne de caractères. Le type et lenombre des autres paramètres à passer dépendent de ce string.Le caractère % est utilisé par la fonction printf() pour indiquer que la valeur d'une variable doit êtreinsérée à cette position. Le caractère qui suit % détermine le type de cette variable. La séquence decaractères de l'exemple précédent %d indique la sortie d'un nombre décimal. D'autres combinaisonspossibles de caractères et leur signification sont indiquées dans le tableau ci-dessous.

Paramètres Signification

%d Sortie d'un nombre décimal (int ou char)

%ld Sortie d'une variable du type long comme nombre décimal

%c Sortie d'un caractère (char)

%x Sortie d'un nombre hexadécimal (avec a...f minuscules)

%x Sortie d'un nombre hexadécimal (avec a...f majuscules)

%o Sortie d'un nombre octal

%u Sortie d'un nombre décimal (uniquement types non signés)

%f Sortie d'une valeur à virgule flottante au format 3.43234 p. ex.

%e Sortie d'une valeur à virgule flottante au format exponentiel23+432 p. ex.

%e Comme %e, mais avec E majuscule, p. ex. 23E+432

%s Sortie d'une chaîne de caractères (char*)

%le Sortie d'une valeur "double"

%% Sortie d'un caractère %

\n Sortie d'un retour chariot (Carriage Return)

\r Sortie d'une nouvelle ligne (Line feed)

\t Sortie d'une tabulation

\\ Sortie d'un caractère \



Fenêtre de diagnostic Global Script

Les tests affichés avec la fonction printf() apparaissent dans la fenêtre de dianostic Global Script. Laprocédure de configuration d'une fenêtre de diagnostic est décrite dans le tableau ci-dessous.

Etape Procédure: Fenêtre de diagnostic Global Script

1 Ouvrez l'éditeur Graphics Designer.

Ouvrez la vue WinCC souhaitée.

2 Configurez un objet complexe Fenêtre d'application.

Une fois que vous l'avez placé dans la vue, le dialogue Contenu de fenêtres'ouvre. Sélection dans la boîte combo Global Script. Quittez le dialogue par OK.

Le dialogue Modèle s'ouvre. Sélection dans la boîte combo Diagnostic GSC.Quittez le dialogue par OK.

3 Pour pouvoir travailler confortablement avec la fenêtre de diagnostic GlobalScript, il est recommandé de paramétrer Oui pour toutes les propriétés dans ledialogue de propriétés d'objet, Autres.

4 Au runtime, les tests sortis avec la fonction printf() sont affichés dans la fenêtrede diagnostic. Si vous arrêtez le rafraîchissement en cliquant sur le bouton de labarre d'outils, vous pouvez également enregistrer et imprimer le contenu de lafenêtre.



4.2 Variables

Pour accéder dans le projet WinCC Project_C_Course aux exemples sur les variables, sélectionnezl'icône ci-dessous dans la barre de navigation. Les exemples sont configurés dans la vuecc_9_example_00.PDL.

Variables

Les variables sont les objets de données manipulés par un programme. Une variable ne peut êtreutilisée qu'après avoir été définie. Toutes les variables utilisées dans un programme doivent êtredéfinies avant que la première instruction du programme soit exécutée.Les variables peuvent être comparées à des contenants. En attribuant un nom à la variable, nousdonnons un nom unique au contenant. Le type du contenu est défini par son type de données. Lecontenu initial est défini par la valeur d'initialisation. C'est pendant l'exécution du programme que cecontenu est généralement manipulé.Les variables décrites ici ne doivent pas être confondues avec les variables WinCC. Elles ne sontdisponibles qu'à l'intérieur du code.Le code ci-dessous contient la définition d'une variable. Il définit une variable du type int dont le nomest iNumber. La ligne de code se termine par un point-virgule. Le nom de la variable est précédé d'unpréfixe désignant le type de données. Ceci n'est pas absolument obligatoire, mais permet de voirimmédiatement le type de la variable lors de la création du programme.

Vous pouvez également initialiser une variable en la définissant.

Constantes

Outre les variables, un programme utilise également des constantes. Il s'agit de l'utilisation directe dela valeur d'un nombre. Pour mettre en évidence la signification d'un tel nombre, vous pouvez définirune constante symbolique avec l'instruction #define.Le code ci-dessous contient un exemple de définition d'une constante symbolique. La constantesymbolique MAX_INT_VALUE est définie avec la valeur 2147483647. Il faut veiller à ne pas terminerla ligne de code par un point-virgule. Une convention très répandue de programmation consiste àécrire les constantes en majuscules pour mieux les différencier des variables.



Types de données

C connaît les types de données de base indiqués dans le tableau ci-dessous.

Type de données Signification

char Un octet permet de programmer un caractère

int Nombre entier

float Nombre à virgule flottante simple précision

double Nombre à virgule flottante double précision

Une variable du type de données char a besoin d'un espace mémoire d'un octet. Son contenu peut êtreinterprété comme caractère ou comme nombre.Le type de données int peut être précédé des mots clés signed ou unsigned. Le mot clé signed signifieque le nombre est précédé d'un signe, le mot clé unsigned qu'il n'est pas signé.Le type de données int peut en outre être aussi précédé des mots clés long ou short. Ces valeurspeuvent également être utilisées sans l'adjonction int avec la même signification. Une variable du typede données short (ou short int) a besoin d'un espace mémoire de 2 octets, une variable du type long(ou long int) a, comme une variable du type int, besoin de 4 octets.Le type double ne se distingue du type float que par son intervalle de valeurs. Le type double permetpar conséquent une meilleure définition des nombres. Une variable du type float a besoin d'un espacemémoire de 4 octets, une variable du type double de 8 octets.

Intervalles de valeurs des types de données

Chaque type de données permet de représenter des nombres à l'intérieur d'un intervalle de valeurs. Lesdifférences résultent des espaces mémoires variables qu'occupent les divers types de données et lestypes signés et non signés.

Type de données Intervalle de valeur

int -2 147 483 648 à 2 147 483 647

unsigned int 0 à 4 294 967 295

short -32 768 à 32 767

unsigned short 0 à 65 535

long -2 147 483 648 à 2 147 483 647

unsigned long 0 à 4 294 967 295

char -128 à 127 (tous les caractères ASCII)

unsigned char 0 à 255 (tous les caractères ASCII)

float -10 ^38 à 10 ^38

double -10 ^308 à 10 ^308



4.2.1 Exemple 1 – Types de données de C (nombres entiers)

Dans cet exemple, tous les types de données proposés par C en standard pour représenter des nombresentiers sont utilisés. L'exemple a été configuré pour l'objet représenté ci-dessous Bouton1 pourl'événement Souris Clic.

Action C pour Bouton1

• Les trois premières lignes sont l'en-tête de l'action C. Il ne peut être modifié.

• La section suivante contient la définition des variables. Elle définit une variable du type char, unedu type long, une du type short et une du type int ainsi que leurs homologues non signées. Le nomde la variable est précédé d'un préfixe désignant le type de données. Ceci n'est pas absolumentobligatoire, mais permet de reconnaître immédiatement le type de données de la variable lors de lacréation ultérieure du programme. Le commentaire contient dans chaque ligne l'espace mémoiredont a besoin la variable (les commentaires sont précédés par les caractères // et sont marqués envert).

• Dans la section suivante, des valeurs sont affectées aux variables. Ceci s'effectue avec l'opérationd'affectation (opérateur =). Les valeurs de l'exemple sont aux limites de l'intervalle de valeursreprésentable des divers types de données.

• Les valeurs sont affichées avec la fonction printf() dans la fenêtre de diagnostic. La sortie écran estreprésentée dans la section suivante.



Affichage dans la fenêtre de diagnostic

L'exemple décrit dans cette section crée la sortie écran suivante dans la fenêtre de diagnostic.



4.2.2 Exemple 2 – Types de données définis par l'utilisateur (nombres entiers)

Vous pouvez, au lieu d'utiliser des types de données standard de C, définir vos propres types dedonnées. Il s'agit cependant d'alias pour les véritables types de données. Cet exemple utilise diverstypes de données définis pour représenter des nombres entiers. L'exemple a été configuré pour l'objetreprésenté ci-dessous Bouton2 et pour l'événement Souris Clic.


• La section suivante contient la définition des variables. Elle définit une variable du type dedonnées CHAR, une du type SHORT, une du type LONG et une du type INT, ainsi que leurshomologues non signés BYTE, WORD, DWORD et UINT. Il est en outre défini une variable dutype BOOL. Aux variables du type BOOL peuvent être affectées les valeurs TRUE ou FALSE.Comme dans l'exemple précédent, un préfixe désignant le type de données précède le nom desvariables.

• Dans la section suivante, des valeurs sont affectées aux variables. Les valeurs de l'exemple sontaux limites de l'intervalle de valeurs pouvant être représenté pour les divers types de données.

• Les valeurs sont affichées avec la fonction printf() dans la fenêtre de diagnostic. La sortie estreprésentée dans la section suivante.




L'exemple décrit dans cette section crée l'affichage suivant dans la fenêtre de diagnostic.

Définition de types de données

Les types de données utilisés dans cette section ont été définis avec l'instruction typedef. Le code ci-dessous montre à titre d'exemple comment le type de données BYTE a été défini. BYTE est toutsimplement un alias pour le type de données standard de C unsigned char. Vous pouvez égalementdéfinir vos propres alias.

Le tableau ci-dessous indique les équivalences entre les types de données définis par l'utilisateur et lestypes de données standard de C.

Type de données défini par l'utilisateur Type de données C

BOOL int

char char

short short

LONG long

int int

octet unsigned char

WORD unsigned short

DWORD unsigned long

UINT unsigned int



4.2.3 Exemple 3 - Variables WinCC (nombres entiers)

Pour pouvoir résoudre des tâches de dynamisation d'objets et autres tâches semblables par une actionC ou une autre fonction, vous devez, dans la plupart des cas, utiliser des variables WinCC. Pour cela,vous disposez de fonctions de lecture et d'écriture dans une variable WinCC. Ces fonctions sontdisponibles pour tous les types de variables standard dans WinCC. Dans cet exemple, des valeursseront écrites dans diverses variables WinCC. Les contenus des variables WinCC sont affichés dansdes champs. L'exemple a été configuré pour l'objet représenté ci-dessous Bouton3 et pour l'événement

Souris Clic.

Action C sur Bouton3

• La première section définit les variables. Les types des variables ont été sélectionnés parmi lestypes disponibles pour les variables WinCC.

• Dans la section suivante, des valeurs sont affectées aux variables. Les nombres utilisés dansl'exemple sont à nouveau aux limites de l'intervalle de valeurs pouvant être représenté pour lesdivers types de données.

• Les valeurs de variables sont affectées aux variables WinCC par les fonctions correspondantes.Les noms de fonction sont constitués du texte SetTag et d'une désignation du type de la variableWinCC à laquelle la fonction est appliquée. Aux fonctions SetTag servant à écrire des variablesWinCC correspondent des fonctions GetTag pour la lecture de variables WinCC.

• Le compilateur émet un avertissement si une variable du type BOOL (alias pour int) est passée à lafonction SetTagBit(). Ceci parce que la fonction SetTagBit() attend comme type pour la variabletransmise le type SHORT. C'est pourquoi, dans l'exemple de code ci-dessus, le contenu de lavariable bNumber est converti au format SHORT avant d'être passé à la fonction SetTagBit(). Cetteopération est également appelée cast.



Transtypage (cast)

Avant d'être passé à une fonction ou à une autre variable, le contenu d'une variable peut être convertidans un autre type de données. Le type de données de la variable lui-même ne s'en touve pas changé.Le code ci-dessous illustre comment le contenu d'une variable peut être converti du type float dans letype int.

Types des variables WinCC

Le tableau ci-dessous indique les correspondances entre les divers types de données de variables et lestypes existant dans C. Il s'agit des types de données qui sont passés aux fonctions SetTag et qui sontretournés par les fonctions GetTag.

Type de la variable WinCC Type de la variable C

Valeur 8 bits signée char

Valeur 16 bits signée short int

Valeur 32 bits signée long int

Variable binaire short int

Valeur 8 bits non signée octet

Valeur 16 bits non signée WORD

Valeur 32 bits non signée DWORD



4.2.4 Exemple 4 – Types de données C (nombres à virgule flottante)

Cet exemple utilise les types de données disponibles en standard dans C pour représenter des nombresà virgule flottante. L'exemple a été configuré pour l'objet représenté ci-dessous Bouton4 et pourl'événement Souris Clic.


• La première section définit les variables. Elle définit une variable du type de données float et unevariable du type double.

• Dans la section suivante, des valeurs sont affectées aux variables. Dans l'exemple, la même valeurest affectée aux deux variables.

• La précision d'une variable du type float va environ jusqu'au septième chiffre décimal. Unevariable du type double permet de représenter un nombre avec une précision double. Ceci peut sevoir en affichant les nombres avec la fonction printf() dans la fenêtre de diagnostic. Les valeurssont affichées avec l'espace mémoire dont elles ont besoin. L'espace mémoire nécessaire à unevariable ou à un type de données se détermine avec l'instruction sizeof(). L'espace mémoire estaffiché en octets.


L'exemple présenté dans cette section crée l'affichage suivant dans la fenêtre de diagnostic.



4.2.5 Exemple 5 - Variables WinCC (nombres à virgule flottante)

Outre les nombres entiers, les variables WinCC peuvent contenir des nombres à virgule flottante.Deux types de données pour variables WinCC correspondant aux types de données C float et doublesont disponibles. Pour permettre l'accès à ces variables WinCC en écriture et en lecteure, des fonctionsSetTag et GetTag sont également disponibles. Dans cet exemple, des valeurs seront écrites dansdiverses variables WinCC. Les contenus des variables WinCC sont affichés dans des champs.L'exemple a été configuré pour l'objet représenté ci-dessous Bouton5 pour l'événement Souris Clic.


• La première section définit les variables. Elle définit une variable du type de données float et unevariable du type double.

• Dans la section suivante, des valeurs sont affectées aux variables. Dans l'exemple, la même valeurest affectée encore une fois aux deux variables.

• Les valeurs de variables sont affectées aux variables WinCC par les fonctions correspondantes.Aux fonctions SetTag servant à écrire des variables WinCC correspondent des fonctions GetTagpour la lecture de variables WinCC.



4.2.6 Exemple 6 – Variables statiques et variables externes

L'exemple a été configuré pour l'objet représenté ci-dessous Bouton5 et pour l'événement Souris Clic .

Variables statiques

Une variable C est valide dans une fonction à partir de sa définition. Elle est invalidée lorsquel'exécution de la fonction est terminée. En cas de nouvel appel, la fonction est recréée. Si une variableest cependant précédée du mot clé static, elle n'est pas invalidée entre deux appels de la fonction. Elleconserve donc également sa valeur. Pour les actions C programmées pour des objets, ceci n'est valableque tant que la vue WinCC est sélectionnée. La variable statique est invalidée lorsque la vue affichéeest annulée. En cas de nouvelle sélection de cette vue, la variable est recréée à la première exécutionde l'action C.

Variables externes

L'accès à une variable C n'est possible qu'à l'intérieur de la fonction dans laquelle elle a été définie. Sila variable est définie en dehors de la fonction, elle devient une variable globale (externe). Si cettevariable est déclarée dans une fonction quelconque avec le mot clé extern, le programme peut yaccéder.

Fonction de projet CreateExternalTags()

• La fonction CreatExternalTags() sert uniquement à définir et à initialiser une variable externe dutype int. La fonction est appelée une seule fois au démarrage du projet (par l'événementAutres Sélection de vue de démarrage cc_0_startpicture_00.PDL). A partir ce cet instant, lavariable ext_iNumber est définie et peut être utilisée dans toutes les actions C et dans toute autrefonction.




• La première section contient la déclaration de la variable externe ext_iNumber, qui pourra ainsiêtre utilisée dans l'action C.

• Dans la seconde section, la variable statique stat_iNumber est définie et initialisée. Ceci a lieu à lapremière exécution de l'action C qui suit la sélection de la vue WinCC. La valeur de la variable estconservée pour les autres exécutions de l'action C. La variable est recréée en cas d'annulation et deresélection de la vue.

• Les valeurs des variables sont incrémentées de 1 au moyen de l'opérateur d'incrémentation ++ etaffichées par la fonction printf() dans la fenêtre de diagnostic. Ainsi la variable ext_iNumberindique le nombre de clics sur le bouton depuis le démarrage du projet et la variable stat_iNumberle nombre des clics sur le bouton depuis la sélection de la vue. Cette sortie à l'écran est présentéedans la section suivante.





4.3 Opérateurs et fonctions mathématiques dans C

Pour accéder aux exemples sur les opérateurs dans le projet WinCC Project_C_Course, cliquez surl'icône représentée ci-dessous de la barre du navigateur. Les exemples sont configurés dans la vuecc_9_example_01.PDL.

Opérateurs

Dans un programme, les opérateurs spécifient ce qui doit se faire avec les variables et les constantes.Variables et constantes sont combinées par des opérateurs pour obtenir de nouvelles valeurs devariables.Les opérateurs se subdivisent en plusieurs catégories. En font partie les opérateurs mathématiques, lesopérateurs de bits et les opérateurs d'affectation.

Opérateurs mathématiques

Opérateur Description

+ (unaire) Signe positif (à vrai dire sans aucun effet)

- (unaire) Signe négatif

+ (binaire) Addition

- (binaire) Soustraction

* Multiplication

/ Division

% Modulo (renvoie le reste de la division)

++ Incrémentation

-- Décrémentation

Opérateurs de bits

Ces opérateurs servent à positionner, tester et désactiver des bits.


& ET sur bits

| OU sur bits

^ OU exclusif sur bits

~ Inversion de bits

<< Décalage de bits vers la gauche

>> Décalage de bits vers la droite



Opérateurs logiques

Tous les opérateurs logiques suivent la règle 0 = FAUX et tout autre nombre = VRAI. Ces opérateursgénèrent un 0 (FALSE) ou un 1 (TRUE).


> plus grand

>= plus grand ou égal

== égal

!= non égal

<= plus petit ou égal

< plus petit

&& ET logique

|| OU logique

! Inversion logique



4.3.1 Exemple 1 - Opérations arithmétiques

Cet exemple utilise les quatre opérations arithmétiques. L'exemple a été configuré pour l'objetreprésenté ci-dessous Bouton1 et pour l'événement Souris Clic.


• Dans la première section, deux variables du type de données float sont définies et initialisées. Lesopérateurs arithmétiques doivent être appliqués à ces deux variables.

• Dans la deuxième section, quatre autres variables du type float sont définies. Ces variables doiventstocker les résultats des opérations arithmétiques à exécuter.

• Dans la section suvante, des calculs sont effectués avec les opérateurs arithmétiques d'addition, desoustraction, de multiplication et de division.

• Les résultats des calculs sont affichés avec la fonction printf() dans la fenêtre de diagnostic. Cettesortie à l'écran est présentée dans la section suivante.





4.3.2 Exemple 2 – Opérateur d'incrémentation et opérateur de décrémentation

Cet exemple utilise l'opérateur d'incrémentation et l'opérateur de décrémentation. L'exemple a étéconfiguré pour l'objet représenté ci-dessous Bouton2 pour l'événement Souris Clic.

Préfixe et postfixe

L'incrément et l'opérateur de décrémentation sont disponibles en version préfixe et postfixe. Les deuxversions exécutent la même action: elles augmentent ou réduisent la valeur de la variable à laquelleelles sont appliquées de 1. La différence réside cependant dans la valeur retournée. La version préfixeincrémente ou décrémente la valeur de la variable et retourne cette nouvelle valeur. La versionpostfixe retourne la valeur intiale de la variable; ce n'est qu'alors que la variable est incrémentée oudécrémentée.


• Dans la première section, deux variables du type de données int sont définies et initialisées.

• L'opérateur d'incrémentation est appliqué à ces deux variables dans sa version préfixe et postfixe.Les valeurs retournées par les opérateurs sont affichées avec la fonction printf() dans la fenêtre dediagnostic. Les contenus des variables sont ensuite également affichés par la fonction printf() dansla fenêtre de diagnostic. Cette sortie à l'écran est présentée dans la section suivante.




L'exemple présenté dans cette section crée l'affichage suivant dans la fenêtre de diagnostic. On voitbien que la version préfixe de l'opérateur d'incrémentation retourne la valeur incrémentée de lavariable alors que la version postfixe, elle, renvoie la valeur initiale de la variable. Dans les deux cas,la variable est cependant incrémentée.



4.3.3 Exemples 3 - Opérations sur bits

Cet exemple utilise les opérateurs de bits fondamentaux. L'exemple a été configuré pour l'objetreprésenté ci-dessous Bouton3 et pour l'événement Souris Clic .

Description

Dans cet exemple, les opérateurs de bits sont appliqués au contenu de deux variables WinCC (valeurs16 bits non signée). Le résultat de l'opération est stocké dans une autre variable WinCC de même typede données. L'opérateur à appliquer est piloté et simultanément affiché par l'objet Bouton6. Vousdisposez des combinaisons de bits AND, OR, NAND, NOR et EXOR. A chacune de ces combinaisonsest affectée une valeur (nombre) qui est stockée dans une autre variable WinCC (valeurs 8 bits nonsignée).




• La première section définit une variable du type de données BYTE et trois variables du typeDWORD. Ces variables servent à stocker en tampon les variables WinCC.

• Dans la section suivante, les deux variables WinCC à combiner sont chargées dans les variablesdwValue1 et dwValue2. La variable WinCC qui détermine la nature de l'opération logique sur bitsà effectuer est chargée dans la variable byOperation.

• Dans la section suivante, les deux variables dwValue1 et dwValue2 sont combinées logiquementbit à bit en fonction du contenu de la variable byOperation. Le résultat de la combinaison logiqueest stocké dans la variable dwResult. La sélection de l'opération logique à exécuter se fait par uneinstruction switch-case. Ceci sera expliqué plus en détail au chapitre Boucles.

• Dans la section suivante du programme, le résultat de l'opération logique contenu dans la variabledwResult est écrit dans la variable WinCC correspondante.



4.3.4 Exemple 4 – Permutation d'octets

Dans cet exemple, les opérateurs de décalage de bits sont utilisés pour permuter les octets de la valeurd'une variable WinCC (valeur 16 bits non signée). Il s’agit d’intervertir octet de poids fort (High) etoctet de poids faible (Low). L'exemple a été configuré pour l'objet représenté ci-dessous Bouton4 etpour l'événement Souris Clic.


• La première section définit une variable du type de données DWORD. Ces variables servent àstocker en tampon la variable WinCC. Il est en outre défini deux variables auxiliaires du typeDWORD.

• Dans la section suivante, la variable WinCC à traiter est chargée dans la variable dwValue.

• Dans la section suivante, les bits de la variable dwValue sont décalés de huits positions (un octet)vers la gauche et stockés dans la variable dwtempValue1. Ensuite les bits de la variable dwValuesont décalés de huits positions vers la droite et stockés dans la variable dwtempValue2. Les deuxvaleurs obtenues dans cette section de programme sont combinées bit à bit (OU) et le résultat eststocké dans la variable dwValue.

• Dans la section suivante du programme, le résultat du décalage d'octets contenu dans la variabledwValue est écrit dans la variable WinCC correspondante.



4.3.5 Exemple 5 – Fonctions mathématiques

Cet exemple présente diverses fonctions mathématiques standard de C. L'exemple a été configurépour l'objet représenté ci-dessous Bouton5 et pour l'événement Souris Clic.


• La première section définit les variables.

• La première fonction appelée est la fonction pow(). Cette fonction nécessite le passage de deuxparamètres. Dans l'exemple, la valeur retournée par la fonction est la puissance trois du contenu dela variable dValue.

• La première fonction appelée est la fonction sqrt(). Cette fonction retourne la racine carrée de lavaleur passée.

• La première fonction appelée est la fonction abs(). Cette fonction retourne la valeur absolue de lavaleur passée.

• La fonction ensuite appelée est la fonction rand(). Cette fonction ne nécessite pas de passage deparamètres. Elle retourne un nombre aléatoire.

• Les résultats des calculs sont affichés avec la fonction printf() dans la fenêtre de diagnostic. Cettesortie à l'écran est présentée dans la section suivante.





Autres fonctions mathématiques

Dans la sélection de fonctions, les fonctions mathématiques se trouvent dans Fonctions internes c_bib math. La figure ci-dessous présente toutes les fonctions mathématiques disponibles (surfond gris).



4.4 Pointeurs

Pour accéder aux exemples sur les pointeurs dans le projet WinCC Project_C_Course, cliquez surl'icône représentée ci-dessous qui est affichée dans la barre du navigateur. Les exemples sontconfigurés dans la vue cc_9_example_02.PDL.

Utilisation des pointeurs

Les pointeurs sont des éléments essentiels du langage C. Un pointeur est une variable contenant uneadresse, généralement l'adresse d'une autre variable.Les pointeurs se définissent comme des variables ordinaires. On ajoute cependant au nom du type devariable à pointer le caractère unaire *. Celui-ci ne doit pas être confondu avec l'opérateur binaire * dela multiplication. Le code ci-dessous définit un pointeur sur une variable du type int.

Le contenu du pointeur n'est pas défini. Il ne pointe pas encore sur une variable valide du type int.Pour l'indiquer clairement, il est recommandé d'initialiser un pointeur avec la valeur NULL à sacréation. La validité du pointeur peut alors être contrôlée avant son utilisation.

Pour diriger le pointeur sur une variable du type de données int, vous devez lui affecter l'adresse de lavariable. Ceci se fait avec l'opérateur unaire ? dit opérateur d'adressage. Celui-ci retourne l'adresse dela variable au lieu de sa valeur. Le code ci-dessous affecte au pointeur l'adresse d'une variable du typeint.

Le programme accède à la valeur des variables à pointer au moyen de l'opérateur unaire *. Cetopérateur est appelé opérateur d'indirection. Le code ci-dessous affecte à une variable du type int lavaleur de la variable adressée par le pointeur.



Utilisation de vecteurs

Pointeurs et vecteurs sont intimement liés. Le code ci-dessous définit un vecteur de 5 variables dutype int.

Un indice permet l'accès aux divers éléments du vecteur. Le code ci-dessous accède au contenu dudernier élément du vecteur. Ceci se fait avec l'opérateur [].

Le nom du vecteur peut également être utilisé comme pointeur vers le premier élément du vecteur. Ilest également possible d'accéder à un élément déterminé du vecteur en déplaçant ce pointeur d'unnombre défini d'éléments. Ceci se fait, comme le montre le code ci-dessous, par l'addition d'une valeurint au pointeur. L'accès au contenu du pointeur obtenu se fait avec l'opérateur unaire d'indirection *.Comme précédemment, il est accédé à la dernière valeur du vecteur.

Chaîne de caractères

Une chaîne de caractères (ou string) peut être définie dans C comme un vecteur de caractères oucomme un pointeur vers un caractère. C ajoute à la fin de la chaîne de caractères codée un caractèreNULL. Celui-ci est interprété comme caractère de terminaison de la chaîne. Le code ci-dessousprésente les deux manières de définir des variables de type String.

Ci-dessous la représentation interne des deux variables de type String. Dans le premier cas de figure, ilest réservé pour la variable de type String autant d'espace mémoire que nécessite le string indiquépour l'initialisation. Dans le second cas, il est réservé autant d'espace qu'il en a été indiqué à ladéfinition du vecteur.

S t r i n g 1 \0

S t r i n g 2 \0 ? ?



4.4.1 Exemple 1 – Pointeur

Cet exemple exécute des opérations fondamentales avec pointeurs. L'exemple a été configuré pourl'objet représenté ci-dessous Bouton1 et pour l'événement Souris Clic.


• Dans la première section, deux variables du type de données int sont définies et initialisées.

• Elle définit ensuite un pointeur vers une variable du type de données int et l'initialise avec la valeurNULL.

• Le code affiche ensuite l'adresse contenue dans le pointeur avec la fonction printf(). Le contenuactuellement désigné par le pointeur n'est pas défini. Un accès au contenu du pointeur avecl'opérateur d'indirection * entraînerait à cet instant une violation générale.

• Le programme affecte ensuite au pointeur l'adresse de la variable iValue1. Le code affiche ensuiteson adresse et son contenu avec la fonction printf().

• Le code affecte ensuite au pointeur l'adresse de la variable iValue2 et affiche le résultat.L'affichage par ce programme est présenté dans la section suivante.





4.4.2 Exemple 2 – Vecteurs

Cet exemple exécute des opérations fondamentales avec vecteurs. L'exemple a été configuré pourl'objet représenté ci-dessous Bouton2 et pour l'événement Souris Clic.


• Le code ci-dessous définit un vecteur de 5 variables du type int. Le vecteur est initialisé avec desnombres à sa définition.

• Il définit ensuite une variable de comptage iIndex du type int.

• Les éléments du vecteur sont affichés par la fonction printf(). L'accès aux éléments du vecteur sefait au moyen d'une boucle for et de l'opérateur d'indice [].L'utilisation des boucles sera traitée auchapitre suivant Boucles. Cette sortie à l'écran est présentée dans la section suivante.





4.4.3 Exemple 3 – Pointeurs et vecteurs

Cet exemple explique les interrelations entre pointeurs et vecteurs. L'exemple a été configuré pourl'objet représenté ci-dessous Bouton3 et pour l'événement Souris Clic.


• Le code ci-dessous définit un vecteur de 5 variables du type int. Le vecteur est initialisé avec desnombres à sa définition. Dans ce cas, vous pouvez ne pas indiquer de taille dans le programme endéfinissant le vecteur.

• Il définit ensuite une variable de comptage iIndex du type int.

• Il définit ensuite un pointeur vers une variable du type int et l'initialise avec la valeur NULL.

• L'adresse du premier élément du vecteur est ensuite affectée au pointeur piElement. Cette adresseest affichée par la fonction printf().

• Le code contient ensuite la programmation de l'accès aux éléments du vecteur par le pointeurpiElement. L'accès se fait par une boucle for, par décalage du pointeur sur les éléments et parl'opérateur d'indirection *.

• Le programme accède ensuite aux éléments du vecteur. Cette fois-ci, c'est le nom du vecteur lui-même qui est utilisé comme pointeur. L'affichage par ce programme est présenté dans la sectionsuivante.







4.4.4 Exemple 4 – Chaînes de caractères (strings)

Cet exemple explique l'utilisation de variables du type String. L'exemple a été configuré pour l'objetreprésenté ci-dessous Bouton4 et pour l'événement Souris Clic.


• La première section définit une chaîne (vecteur de 13 caractères). La longueur de cette chaîne a étédéfinie avec un caractère de plus que celle de la chaîne d'initialisation affectée, afin de prévoir dela place pour le caractère de terminaison 0.

• Elle définit ensuite une variable de comptage iIndex du type int.

• Les caractères de la chaîne sont ensuite affichés par la fonction printf() . L'accès aux caractères sefait dans une boucle for avec l'opérateur d'indice [].

• La totalité de la chaîne est ensuite affichée par la fonction printf(). L'affichage par ce programmeest présenté dans la section suivante.





4.4.5 Exemple 5 – Variables de texte WinCC

Cet exemple explique les liens entre les variables C de type String et les variables de texte WinCC.L'exemple a été configuré pour l'objet représenté ci-dessous Bouton5 et pour l'événement Souris

Clic.


• La première section définit une chaîne de caractères (pointeur vers le premier caractère). Celle-ciest initialisée avec la valeur NULL.

• La fonction GetTagChar() lit ensuite le contenu d'une variable de texte WinCC. La fonctionréserve elle-même l'espace mémoire nécessaire pour la chaîne de caractères et retourne l'adressedu début de la chaîne.

• La totalité de la chaîne est ensuite affichée par la fonction printf(). La longueur de la chaîne decaractères est ensuite déterminée par la fonction strlen() puis affichée avec l'adresse du début de lachaîne. L'affichage par ce programme est présenté dans la section suivante.





4.5 Boucles et instructions conditionnelles

Pour accéder aux exemples sur les boucles dans le projet WinCC Project_C_Course, cliquez surl'icône représentée ci-dessous qui est affichée dans la barre du navigateur. Les exemples sontconfigurés dans la vue cc_9_example_03.PDL.

Boucles

Une boucle permet d'exécuter une partie de code tant qu'une condition est vraie.Il existe d'une manière générale deux types de boucles : Les boucles avec test en début et les bouclesavec test en fin de boucle. Les boucles de la première catégorie testent les conditions avant l'exécutiondu corps de la boucle. Les boucles de la seconde catégorie testent les conditions après l'exécution ducorps de la boucle. Il en résulte que les boucles à test en fin de boucle sont exécutées au moins unefois.On distingue les types de boucles suivants.

while

Ci-après un exemple de boucle while. Les instructions de la boucle sont répétées tant que la conditiond'exécution est remplie. Dans l'exemple, la boucle est exécutée tant que la valeur de la variable i estinférieure à 5.

do - while

Ci-après un exemple de boucle do-while. Cette boucle est exécutée au moins une fois, puis répétéetant que la condition est remplie. Dans l'exemple, la boucle est exécutée tant que la valeur de lavariable i est inférieure à 5.



for

Ci-après un exemple de boucle for. Les instructions de la boucle sont répétées tant que la conditiond'exécution est remplie. L'initialisation du compteur de passages de boucle et le traitement ducompteur de passages peuvent être formulés dans la boucle.

Instructions conditionnelles

Les boucles exécutent un corps de boucle tant qu'une condition est remplie (vraie). Les instructionsconditionnelles sont exécutées exactement une fois si une condition est remplie.

On distingue les types d'instructions conditionnelles suivantes.

if-else

Si la condition est vraie, l'instruction est exécutée dans la branche if. Si la condition n'est pas remplie,c'est l'instruction alternative de la branche else qui est exécutée. On peut omettre la branche else,auquel cas aucune instruction alternative n'est exécutée.

Test multiple switch-case

On vérifie ici l'égalité d'une variable. L'instruction switch sert à définir la variable à tester. Il est testédans quelle branche case il y a égalité de la variable. Cette branche case est alors exécutée.L'instruction peut comporter un nombre illimité de branches case. Chaque branche case doit êtreterminée par un break. Le mot clé facultatif default peut également être ajouté. Cette branche est alorsexécutée si la valeur de la variable à tester ne correspond à aucune des branches case.



4.5.1 Exemple 1 – Boucle while

Cet exemple explique l’utilisation de la bouche while. L'exemple a été configuré pour l'objetreprésenté ci-dessous Bouton1 et pour l'événement Souris Clic.


• La première section définit et initialise une variable de comptage iCount du type int.

• Une boucle while est ensuite programmée. Celle-ci est exécutée tant que le contenu de la variablede comptage iCount est inférieur à 5. Une sortie écran est générée à chaque passage de la bouclepar la fonction printf(). En fin de boucle, le compteur iCount est incrémenté de 1. L'affichage parce programme est présenté dans la section suivante.





4.5.2 Exemple 2 – Boucle do-while

Cet exemple explique l’utilisation de la boucle do-while. L'exemple a été configuré pour l'objetreprésenté ci-dessous Bouton2 et pour l'événement Souris Clic.



• Une boucle do-while est ensuite programmée. Celle-ci est exécutée tant que le contenu de lavariable de comptage iCount est inférieur à 5. Elle est cependant exécutée au moins une fois, carcette condition n'est testée qu'après l'exécution du corps de la boucle. Une sortie écran est généréeà chaque passage de la boucle par la fonction printf(). En fin de boucle, le compteur iCount estincrémenté de 1. L'affichage par ce programme est présenté dans la section suivante.





4.5.3 Exemple 3 – Boucle for

Cet exemple explique l’utilisation de la bouche for. L'exemple a été configuré pour l'objet représentéci-dessous Bouton3 et pour l'événement Souris Clic.



• Une boucle for est ensuite programmée. Celle-ci est exécutée tant que le contenu de la variable decomptage iCount est inférieur à 5. L'initialisation de la variable de comptage est programméedirectement avec l'appel de la boucle; il en va de même pour l'action d'incrémentation de lavariable de comptage. Une sortie écran est générée à chaque passage de la boucle par la fonctionprintf(). L'affichage par ce programme est présenté dans la section suivante.





4.5.4 Exemple 4 – Boucles sans fin

Cet exemple explique les boucles sans fin. Celles-ci résultent généralement d'erreurs deprogrammation qui font qu'une condition de boucle est toujours remplie. Elles peuvent cependantaussi être programmées intentionnellement. Dans ce cas, l'interruption de la boucle doit être réaliséeautrement, à savoir par l'instruction break. L'exemple a été configuré pour l'objet représenté ci-dessous Bouton4 et pour l'événement Souris Clic.




• La première section définit la constante symbolique MAX_COUNT. Celle-ci contient le nombremaximal de passages de la boucle sans fin ci-dessous.

• La section suivante définit et initialise une variable de comptage iCount du type int.

• Le nombre courant des passages de la boucle doit être affiché par une barre de progression. Celle-ci est constituée d'une barre dont la longueur contient la variable iProgressBar et d'un textestatique dont le contenu contient la variable de type String szProgressText.

• Une boucle sans fin est ensuite programmée. Celle-ci peut également être formulée avecl'instruction while (TRUE).

• La boucle teste la variable de comptage iCount. Si cette valeur de compteur dépasse la valeurMAX_COUNT, la boucle est quittée par l'instruction break.

• Le compteur iCount est incrémenté.

• La barre de progression affiche en pourcentage les passages déjà exécutés. Les valeurs del'affichage de progression sont rafraîchies à chaque point de pourcentage terminé. Tant qu'unnouveau point de pourcentage n'est pas achevé, un nouveau passage de boucle est immédiatemententamé avec l'instruction continue et les lignes suivantes du programme sont sautées.

• Les valeurs de l'affichage de progression sont définies par réglage de la largeur de la barre deprogression ProgressBar avec la fonction SetWidth() et le texte statique ProgressText avec lafonction SetText(). Le texte utilisé est composé par la fonction sprintf(). Cette fonction travailleselon le principe de printf(). Le texte n'est cependant pas écrit dans la fenêtre de diagnostic GlobalScript, mais dans une variable du type String. Celle-ci doit être déclarée comme premier paramètrede la fonction.



4.5.5 Exemple 5 – Instruction if-else

Cet exemple explique l’utilisation de l’instruction if-else. L'exemple a été configuré pour l'objetreprésenté ci-dessous Bouton5 et pour l'événement Souris Clic.


• La première section de code définit une variable byValue du type BYTE. Cette variable doit stockerle contenu d'une variable WinCC.

• La section suivante charge le contenu d'une variable WinCC avec la fonction GetTagByte() dans lavariable byValue.

• Une instruction if-else est ensuite programmée. Celle-ci fait dépendre du contenu de la variablebyValue un affichage par la fonction printf().



4.5.6 Exemple 6 – Instruction switch-case

Cet exemple explique l’utilisation de l’instruction switch-case. L'exemple a été configuré pour l'objetreprésenté ci-dessous Bouton6 et pour l'événement Souris Clic.


• La première section de code définit une variable byValue du type BYTE. Cette variable doit stockerle contenu d'un variable WinCC.

• La section suivante charge le contenu d'une variable WinCC avec la fonction GetTagByte() dans lavariable byValue.

• Une instruction switch-case est ensuite programmée. Celle-ci fait dépendre du contenu de lavariable byValue un affichage par la fonction printf(). Pour exécuter les mêmes instructions pourplusieurs valeurs numériques de la variable testée, vous devez imbriquer les branches case. Lesinstructions à exécuter se programment dans la dernière branche case.



4.6 Fonctions

Pour accéder aux exemples sur les fonctions dans le projet WinCC Project_C_Course, cliquez surl'icône représentée ci-dessous de la barre du navigateur. Les exemples sont configurés dans la vuecc_9_example_05.PDL.

Fonctions

Les fonctions servent à mieux structurer le code d'un programme. Vous pouvez placer dans unefonction des instructions qui reviennent fréquemment au lieu de les reprogrammer à chaque fois. Lecode peut alors être modifié de manière centralisée et sa maintenabilité s'en trouve accrue.Dans WinCC, les fonctions peuvent être créées comme fonctions de projet ou comme fonctionsstandard.

Paramètres transmis

Il est possible de passer des valeurs aux fonctions; la fonction exécute des instructions d'après lesvaleurs transmises. Ces valeurs peuvent être transmises de plusieurs manières.

• On peut passer:

• une variable; seule la valeur de la variable est cependant passée à la fonction; la fonction ne peutaccéder à la variable elle-même;

• un pointeur; la fonction peut ainsi accéder à la variable désignée par le pointeur; les vecteurs et lesstructures ne peuvent être passés à une fonction que par des pointeurs.

Valeur retournée

Une fonction peut simplement exécuter des instructions et ne rien retourner. La valeur retournée estalors du type void. Lorsque, par contre, un calcul, par exemple, doit être exécuté, la valeur obtenuepeut être retournée au programme ayant appelé la fonction. Il est ainsi possible de retourner desvaleurs et des adresses.Une autre possibilité de retourner des valeurs au programme appelant consiste à écrire dans une zoned'adressage qui est passée comme paramètre. Les vecteurs et les structures ne peuvent être retournésque de cette manière



4.6.1 Exemple 1 – Passage de paramètres par valeur

Cet exemple crée une fonction simple pour le calcul de la moyenne arithmétique de trois nombres. Lesparamètres sont passés sous forme de valeurs; le résultat est également retourné comme valeur.L'exemple a été configuré pour l'objet représenté ci-dessous Bouton1 et pour l'événement Souris

Clic.

Fonction de projet MeanValue()

• Le nom de la fonction est défini par MeanValue() dans l'en-tête de la fonction. Trois variables dutype double doivent être passées à la fonction. Une variable du type double est égalementretournée.

• Il est ensuite défini une variable du type double dans laquelle la valeur retournée doit être stockée.Celle-ci est calculée par addition des trois valeurs transmises; le résultat de cette addition est divisépar trois.

• Le résultat est retourné au programme appelant par l'instruction return.




• Dans la première section, trois variables du type de données double sont définies et initialisées. Ils'agit de calculer la moyenne des trois variables. On définit une autre variable du type double pourstocker le résultat du calcul.

• La moyenne est calculée avec les variables transmises par la fonction précédemment crééeMeanValue().

• Le résultat du calcul est affiché par la fonction printf(). Cette sortie à l'écran est présentée dans lasection suivante.





4.6.2 Exemple 2 – Passage de paramètres par adresse

Cet exemple présente une fonction simple pour le calcul de la moyenne des éléments d'un vecteur delongueur quelconque. Cette fonction transmettra l'adresse du vecteur et sa longueur. Le résultat estretourné comme valeur. L'exemple est configuré sur l'objet représenté ci-dessous Bouton2 pourl'événement Souris Clic.

Fonction de projet MeanValueVector()

• Le nom de la fonction est défini par MeanValueVector(). Un pointeur vers une variable du typedouble doit être passé à la fonction. Ce pointeur désigne le premier élément du vecteur attendu. Lalongueur du vecteur doit aussi être passée à la fonction. Une variable du type double seraretournée.

• Il est ensuite défini et initialisé une variable du type double. Elle doit servir à stocker la somme deséléments du vecteur transmis. Cette somme est déterminée au moyen d'une boucle for.

• Le résultat est passé au programme appelant par l'instruction return. Le résultat est la somme deséléments du vecteur divisée par le nombre de ses éléments.




• La première section définit et initialise un vecteur de trois variables du type double. La moyennede ces trois variables doit être calculée. On définit une autre variable du type double pour stockerle résultat du calcul.

• La moyenne des éléments du vecteur transmis est calculée au moyen de la fonction précédemmentcréée MeanValueVector().

• Le résultat du calcul est affiché par la fonction printf(). Cet affichage est présenté dans la sectionsuivante.





4.6.3 Ecriture dans un vecteur transmis

Cet exemple présente une fonction simple pour le remplissage d'un vecteur de longueur quelconqueavec des nombres aléatoires. Cette fonction transmettra l'adresse d'un vecteur et sa longueur. La valeurretournée par la fonction indique par une variable du type BOOL si l'action a été exécutéecorrectement. L'exemple est configuré sur l'objet représenté ci-dessous Bouton3 pour l'événement

Souris Clic.

Fonction de projet FillVector()

• Le nom de la fonction est défini par FillVector(). Un pointeur vers une variable du type int doitêtre passé à la fonction. Ce pointeur désigne le premier élément du vecteur attendu. La longueur duvecteur doit aussi être passée à la fonction. Une variable du type BOOL indiquant si la fonction aété exécutée correctement ou non est retournée.

• Il est ensuite défini et initialisé une variable de comptage du type int.

• Le pointeur transmis est ensuite vérifié. Le programme appelant est responsable de l'exactitude dela longueur du vecteur. Le passage d'une valeur erronée peut entraîner une violation générale.

• Les éléments du vecteur transmis sont remplis à l'aide d'une boucle for et de la fonction rand().



Action C sur Bouton 3

• La première section de code définit une constante symbolique VECTOR_SIZE pour le nombre deséléments du vecteur.

• Il est ensuite défini un vecteur iVector constitué de variables VECTOR_SIZE du type de donnéesint.

• Il est ensuite défini une variable de comptage i du type int.

• La fonction précédemment créée FillVector() remplit de nombre aléatoires les éléments du vecteurtransmis iVector. La valeur retournée par la fonction FillVector() est immédiatement testée par uneinstruction if au moment de son appel.

• Les éléments du vecteur iVector sont affichés par la fonction printf(). Cet affichage est présentédans la section suivante.





4.6.4 Renvoi de l'adresse du résultat

Cet exemple présente une fonction simple pour le remplissage d'un vecteur avec des nombresaléatoires. La longueur du vecteur souhaité est passée à la fonction comme paramètre. La fonctionretourne l'adresse du premier élément du vecteur créé. L'exemple est configuré sur l'objet représentéci-dessous Bouton4 pour l'événement Souris Clic.

Fonction de projet GetFilledVector()

• Le nom de la fonction est défini par GetFilledVector. Le nombre des éléments du vecteur à créerdoit être passé à la fonction. Le pointeur vers le premier élément du vecteur créé du type int* estretourné par la fonction.

• Un pointeur piVector vers une variable du type int est ensuite défini puis initialisé avec NULL.


• On doit réserver un espace mémoire suffisant pour le vecteur. Cette réservation se fait avec lafonction interne SysMalloc(). Il faut passer à cette fonction la taille de la zone de mémoire obtenueen multipliant l'espace mémoire d'une variable du type int par le nombre souhaité d'éléments devecteur. La fonction retourne l'adresse de la zone mémoire réservée ou NULL lorsque la mémoiredisponible est insuffisante.

• Le programme vérifie ensuite l'adresse retournée par la fonction SysMalloc(). Si l'espace mémoireétait insuffisant, la fonction est terminée et la valeur NULL est retournée.

• Les éléments du vecteur transmis sont remplis à l'aide d'une boucle for et de la fonction rand().

• L'adresse du vecteur créé est retournée par l'instruction return au programme appelant.




• La première section de code définit une constante symbolique VECTOR_SIZE pour le nombre deséléments du vecteur.

• Un pointeur piVector vers une variable du type int est ensuite défini puis initialisé avec NULL.


• A l'aide de la fonction précédemment créée GetFilledVector(), on crée un vecteur rempli denombres aléatoires dont l'adresse est stockée dans le pointeur piVector. La validité de la valeurretournée par la fonction GetFilledVector() est ensuite testée.

• Les éléments du vecteur créé sont affichés par la fonction printf(). Cet affichage est présenté dansla section suivante.



Remarque:Il sera expliqué au chapitre suivant comment procéder pour transmettre des structures à desfonctions et comment retourner des structures au programme appelant.



4.7 Structures

Pour accéder aux exemples sur les structures dans le projet WinCC Project_C_Course, cliquez surl'icône représentée ci-dessous affichée dans la barre d'outils du navigateur. Les exemples sontconfigurés dans la vue cc_9_example_04.PDL.

Définition d'un type de structure

Outre les types de données standard, vous pouvez aussi définir vos propres types de données enutilisant des structures. Une définition de type de structure est présentée dans le code ci-dessous. Letype de structure défini est constitué d'un champ int et d'un champ float. Un nom doit être attribué àchaque champ de la structure.

Utilisation d'une variable structurée

Une fois le nouveau type de structure défini vous pouvez définir des variables du type structExampleStruct. Ceci est exposé dans le code ci-dessous. Le code montre en même temps comment sefait l'accès aux champs de la variable structurée.

Si l'on ne dispose que d'un pointeur vers une structure au lieu de la structure elle-même, il est possibled'y accéder comme le montre le code ci-dessous. Il faut alors veiller à ce que le pointeur désigne bienune structure valide ou du moins à ce de l'espace mémoire a bien été réservé pour cette variable.



4.7.1 Exemple 1 – Structure

Cet exemple explique la définition et l'utilisation d'un type de structure simple. L'exemple estconfiguré pour l'objet représenté ci-dessous Texte statique1 et pour l'événement Souris Clic gauche.

Action C pour Texte statique1

• La première section du code définit un type de structure CC_POINT constitué de deux champs int.Ce type de structure doit contenir les coordonnées d'un clic de la souris.

• Il est ensuite défini une variable structurée posObject du type struct CC_POINT.

• Des valeurs sont ensuite affectées aux champs de la structure posObject. Les valeurs assignéessont les coordonnées du clic. Ces coordonnées sont transmises par une action C programmée pourl'événement Souris Clic gauche, dans les paramètres x et y.

• Ensuite, les coordonnées d'un objet sont réglées par les fonctions SetLeft() et SetTop() sur lesvaleurs contenues par la structure.



4.7.2 Exemple 2 – Définition de type de structure

Cet exemple explique la définition et l'utilisation d'un autre type de structure simple. A la différencede l'exemple précédent, ce type de structure doit être disponible dans la totalité du projet et passeulement dans une action C. L'exemple est configuré pour l'objet représenté ci-dessous Bouton2 pourl'événement Souris Clic.

Définition de la structure dans apdefap.h

• Il est défini le type de structure tagCC_RECT, constitué de quatre champs int. Ce type de structuredoit contenir la position et les dimensions d'une zone rectangulaire. Théoriquement, il faudraitdéfinir une variable de ce type comme variable du type struct tagCC_RECT. Pour éviter cetteprocédure en partie laborieuse, on définit un alias avec l'instruction typedef. Il suffit maintenantpour définir une variable de ce type d'utiliser la notation CC_RECT. Pour définir un pointeur versune variable de ce type, on peut utiliser la notation PCC_RECT.




• La première section du code définit et initialise une variable rect du type CC_RECT.

• Un pointeur prect vers une variable du type PCC_RECT est ensuite défini puis initialisé avecNULL. Ce type de variable est un pointeur vers une variable du type CC_RECT.

• Le programme accède ensuite aux quatre champs de la structure rect par l'opérateur "." . Lecontenu de ces champs est affiché par la fonction printf().

• Il est ensuite affecté au pointeur prect l'adresse de la variable rect. Puis le programme accède parl'opérateur -> aux quatre champs de la structure désignée par le pointeur prect. Le contenu de lastructure est affiché par la fonction printf(). L'affichage du programme est codé dans la sectionsuivante.





4.7.3 Exemple 3 – Type de structure WinCC

Cet exemple explique la définition et l'utilisation d'un type de structure WinCC. Ce type de structuredoit correspondre dans sa forme au type CC_RECT défini dans l'exemple précédent. L'exemple estconfiguré sur l'objet représenté ci-dessous Bouton3 pour l'événement Souris Clic.

Création d'un type de structure WinCC

Etape Procédure: Création d'un type de structure WinCC

1 On définit un type de structure WinCC dans WinCC Explorer. Ouvrez le dialoguede définition des propriétés d'une nouvelle structure WinCC par les commandes

D sur Types de structures et Nouveau type de structure.

2 Le dialogue Propriétés - Structures s’ouvre.

Vous devez définir le nom du nouveau type de structure. Pour cela, activez les

commandes D sur le nom par défaut NouvelleStructure et Renommer. Le nomutilisé dans l'exemple est Rect.

3 Vous devez définir les champs du nouveau type de structure.

Le bouton Nouveau champ permet d'ajouter un nouvel élément. Le nom et le type

de données du nouveau champ se définissent par D. Dans l'exemple, lechamp a le nom Left et le type de données LONG. On a choisi pour ce champl'option Variable interne. Les noms et types de données attribués aux autreschamps peuvent être lus dans la figure ci-dessous.

Fermez le dialogue Propriétés - Structure par OK.

4 Vous pouvez maintenant créer des variables WinCC du type Rect. Ceci a poureffet dans cet exemple de créer quatre variables correspondant aux quatre champsde la structure.




• La première section du code définit une variable rect du type CC_RECT. Le type de donnéesCC_RECT a été défini dans l'exemple précédent.

• Les valeurs contenues dans une structure WinCC sont ensuite chargées dans les champs de lavariable rect. Les valeurs contenues dans la structure WinCC sont affichées dans l'exemple parquatre champs E/S, dans lesquels elles peuvent être éditées.

• Les champs de la structure rect sont alors affichés par la fonction printf(). L'affichage duprogramme est codé dans la prochaine section.





4.7.4 Exemple 4 – Fonction de lecture d'un type de structure WinCC

Cet exemple crée une fonction pour la lecture de la structure WinCC définie dans l'exemple précédent.Elle peut alors être utilisée comme les fonctions internes GetTag. L'exemple est configuré pour l'objetreprésenté ci-dessous Bouton4 pour l'événement Souris Clic.

Fonction de projet GetTagRect()



• La première section du code lie au programme le fichier apdefap.h, qui contient la définition dutype de structure tagCC_RECT.

• Le nom de la fonction est défini par GetTagRect dans l'en-tête de la fonction. Il faut passer à lafonction une variable du type String qui contient le nom de la structure WinCC à lire. La fonctionretourne un pointeur vers une cellule mémoire dont le type de données n'est pas précisé (void*).

• Dans la section suivante, une variable prect du type PCC_RECT est définie puis initialisée avecNULL. Ce type de variable est un pointeur vers une variable du type CC_RECT.

• Puis une variable de type String destinée à contenir le nom des champs de la structure WinCC estdéfinie.

• Il faut ensuite réserver un espace mémoire suffisant pour une variable du type CC_RECT. Cetteréservation se fait avec la fonction interne SysMalloc(). Vous devez lui passer comme paramètre lataille de la zone mémoire souhaitée, qui peut être déterminée avec l'instruction sizeof(). Lafonction retourne l'adresse de la zone mémoire réservée ou NULL lorsque la mémoire disponibleest insuffisante.

• Le programme vérifie ensuite l'adresse retournée par la fonction SysMalloc(). Si l'espace mémoireétait insuffisant, la fonction est terminée et la valeur NULL est retournée.

• Ensuite, le nom de chaque champ de la structure WinCC est composé et le contenu du champcorrespondant est transféré dans l'espace mémoire réservé.

• La fonction retourne l'adresse de la zone mémoire réservée dans laquelle le contenu de la structureWinCC a été stocké. Cette zone mémoire reste réservée une fois l'exécution de la fonctionterminée et conserve ses données.

Remarque:Si, au lieu de la procédure proposée ici, on avait créé une structure locale du typeCC_RECT, dont les champs auraient été connectés à ceux de la structure WinCC, etretourné leur adresse, le programme appelant recevrait un pointeur non valide. Ceci parceque la variable du type CC_RECT deviendrait invalide à la fin de l'exécution de la fonction,ce qui entraînerait le renvoi au programme appelant de l'adresse d'un objet invalide.




• Dans la première section, une variable prect du type PCC_RECT est définie puis initialisée avecNULL.

• Ensuite la fonction précédemment créée GetTagRect() lit le contenu d'une structure WinCC. Lafonction GetTagRect() retourne un pointeur vers la zone mémoire qui contient les donnéessouhaitées. Ce pointeur est converti en pointeur du type PCC_RECT.

• Le code vérifie ensuite le pointeur reçu par la fonction GetTagRect(). Si l'espace mémoire estinsuffisant, la fonction retourne la valeur NULL.

• Ensuite, le nom de chaque champ de la structure WinCC est composé et le contenu du champcorrespondant est transféré dans l'espace mémoire réservé.

• La fonction retourne l'adresse de la zone mémoire réservée dans laquelle le contenu de la structureWinCC a été stocké. Cette zone mémoire reste réservée une fois l'exécution de la fonctionterminée et conserve ses données.

• Puis les champs de la structure pointée par prect sont affichés par printf(). L'affichage duprogramme est codé dans la section suivante.



Fonction de projet SetTagRect()

On a créé en plus de la fonction GetTagRect() une fonction SetTagRect() correspondante. Dansl'exemple, cette fonction est utilisée pour l'événement Autres Sélection de vue de la vuecc_9_example_04.PDL pour initialiser la structure.



4.8 API WinCC

Pour accéder aux exemples sur l'API WinCC dans le projet WinCC Project_C_Course, cliquez surl'icône représentée ci-dessous affichée dans la barre d'outils du navigateur. Les exemples sontconfigurés dans la vue cc_9_example_10.PDL.

Interface de programmation WinCC

WinCC met à la disposition de l'utilisateur une API (Application Program Interface) auxfonctionnalités étendues, ouverte et évolutive. Il s'agit d'une interface par laquelle les applicatifspeuvent accéder à WinCC. Les fonctions de l'API WinCC peuvent cependant être utilisées à l'intérieurdu projet WinCC.Le kit de dévelppement WinCC ODK (Open Developers Kit) fournit une vaste description de l'APIWinCC. Il contient des explications extrêmement précises de l'API WinCC au moyen de descriptionsde fonctions et d'un grand nombre d'exemples. Il contient également tous les fichiers d'en-tête avec lesdéclarations de fonction nécessaires. Le kit ODK WinCC n'est cependant pas inclus dans le packagede base WinCC et doit être acheté séparément.

Bibliothèques de fonctions

Chaque application importante de WinCC (Graphics Designer, Tag Logging, Alarm Logging usw.),contient sa propre API dans une ou plusieurs DLL. On entend ici par DLL (Dynamic Load Library)une bibliothèque de fonctions qui se charge dynamiquement. Les déclarations des fonctions placéesdans une DLL se trouvent dans un fichier d'en-tête associé.Le code ci-dessous montre à titre d'exemple la liaison d'une DLL à une action C ou à une autrefonction. La première ligne contient le nom de la DLL à charger. Il s'agit dans l'exemple de la DLLqui contient les fonctions CS de Graphics Designers. La seconde ligne lie au programme le fichierd'en-tête contenant les déclarations des fonctions. Lorqu'une ou deux fonctions seulement sontnécessaires, la déclaration de la (ou des deux) fonction(s) peut également être programmée ici. Ladéclaration se termine par la ligne #pragma code(). Dans cet exemple, les noms de DLL et de fichierd'en-tête sont les mêmes, ce qui paraît judicieux. Ce n'est cependant pas toujours le cas.

Fonctions RT et fonctions CS

On peut classer grossièrement les fonctions API de chaque application en deux types. Les fonctionsCS (système de configuration) et les fonctions RT (runtime).Les fonctions RT peuvent généralement être appelées dans le projet WinCC sans qu'il soit nécessairede charger une DLL spécifique. Les fonctions RT n'ont d'effets que sur le runtime. Au redémarrage duprojet ou, dans la plupart des cas, après un changement de vue, les modifications faites par fonctionsRT sont perdues.Avant d'utiliser une fonction CS dans le projet WinCC, vous devez charger la DLL dans laquelle estprogrammée cette fonction. L'utilisation de fonctions CS dans le projet WinCC même n'est cependantque rarement judicieuse. Ceci est montré dans l'exemple, car il est possible d'en dégager le principe debase de l'utilisation des fonctions CS.



Exemple de projet

Le projet exemple ne contient pas d'explications détaillées de l'API de chaque application WinCC. Ilpermet cependant de se familiariser avec les principes généraux de l'utilisation de l'API WinCC àl'aide de l'API de Graphics Designers. Les exemples utilisent des objets de la vue spécialementconfigurée à cet effet cc_9_example_10x.PDL. Ceci est affiché dans une fenêtre dans la vue affectéeau présent chapitre.



4.8.1 Exemple 1 – Modification de propriétés avec la fonction RT

Cet exemple présente l'utilisation de la fonction RT de l'API de Graphics Designer pour leparamétrage des propriétés d'objets. Il s'agit de modifier la position d'un objet par paramétrage de sespropriétés PositionX et PositionY. L'exemple est configuré pour l'objet représenté ci-dessous Bouton1pour l'événement Souris Clic.


• La première section du code définit et initialise une variable bRet du type BOOL. Cette variabledoit stocker la valeur retournée par la fonction API appelée.

• Deux variables de type String sont ensuite définies. Leur contenu définira l'objet à traiter. Il s'agitdu nom du vue et du nom d'objet. Attention: le nom de vue s'indique sans l'extension PDL.

• Il faut définir une variable déterminant le type des propriétés à paramétrer. Il existe pour cela untype de données spécifique. Il s'agit du type VARTYPE. Une constante symbolique est définie pourchaque type de propriété existant. Les propriétés à paramétrer dans cet exemple sont du typeVT_I4 (int et ont une longueur de 4 octets).

• Il est défini pour chacune des propriétés à paramétrer PositionX et PositionY une variable du typeint qui contient la nouvelle valeur de la propriété.



• Il est ensuite défini une variable du type CMN_ERROR. Il s'agit d'une structure permettantd'obtenir, en cas d'échec d'un appel de fonction, des informations sur l'erreur survenue.

• La fonction d'API PDLRTSetPropEx() permet de paramétrer les propriétés PositionX et PositionYde l'objet défini. Le premier paramètre de la fonction API désigne le mode d'adressage de l'objet.Les trois paramètres suivants désignent le nom de vue souhaité, le nom d'objet et le nom de lapropriété. Il faut pour définir la propriété souhaitée utiliser le nom anglais et pas le nom français.Dans l'exemple précédent, ce sont par conséquent Left et Top. Le paramètre suivant désigne le typede propriété. Le paramètre suivant sert à indiquer l'adresse de la variable qui contient la nouvellevaleur. Les quatre paramètres suivants ne concernent pas la fonctionnalité souhaitée. Le dernierparamètre sert à indiquer l'adresse de la structure d'erreur.

• La valeur retournée par chaque fonction d'API est vérifiée après son appel par une instruction if.En cas d'échec de l'appel, cet échec est affiché. L'information contenue dans le champ szErrorTextde la structure d'erreur constitue un élément de l'affichage.

Remarque:Dans l'exemple, la valeur retournée par la fonction d'API appelée est affectée à une variabledu type BOOL. Cette variable est alors vérifiée. L'appel de la fonction d'API et le contrôlede la valeur retournée peuvent être regroupés dans une ligne de code. C'est cette méthodequi sera utilisée dans les prochains exemples présentés dans ce chapitre.



4.8.2 Exemple 2 – Création d'une liaison à une variable avec fonction RT

Cet exemple présente l'utilisation de la fonction RT de l'API de Graphics Designer pour la créationd'une liaison à une variable. On crée une liaison à une variable pour la propriété Entrée/Sortie

Valeur sortie d’un champ E/S. L'exemple est configuré pour l'objet représenté ci-dessousBouton2 et pour l'événement Souris Clic.


• Dans la dernière section du code, le fichier trigger.h est lié au programme. Ce fichier contient ladéfinition d'une constante symbolique utilisée dans l'exemple.

• Deux variables de type String sont ensuite définies. Leur contenu définira l'objet à traiter. Il s'agitdu nom de vue et du nom d'objet.

• Un type de données spécifique est disponible pour définir les propriétés d'une liaison de variable.Il s'agit du type de la structure de type LINKINFO. On définit une variable link du typeLINKINFO.

• Il est ensuite défini une variable du type CMN_ERROR.

• Les champs de la variable link doivent être remplis avec les informations sur la liaison de variablesouhaitée. On affecte au champ LinkType de la structure la constante symboliqueBUBRT_LT_VARIABLE_DIRECT. Elle représente une liaison directe à une variable. On affecte auchamp dwCycle la valeur 0 qui correspond au déclencheur Sur modification. Le champszLinkName définit la variable à utiliser.

• On crée avec la fonction d'APIPDLRTSetLink() une liaison de variable pour l'objet défini. Lepremier paramètre de la fonction API désigne le mode d'adressage de l'objet. Les trois paramètressuivants désignent le nom de vue souhaité. le nom d'objet et le nom de la propriété. Le paramètresuivant sert à indiquer l'adresse de la variable link qui définit la liaison de variable à créer. Lesdeux paramètres suivants ne concernent pas la fonctionnalité souhaitée. Le dernier paramètre sert àindiquer l'adresse de la structure d'erreur. Un message est affiché si l'appel de la fonction d' APIéchoue.



Remarque:Les deux premiers exemples de ce chapitre concernent l’objet ChampE/S1 de la vuecc_9_example_10x.PDL. Le premier exemple modifie la position de l’objet dans la vue; lesecond crée une liaison de variable pour cet objet. Les modifications effectuées sontperdues après un changement de vue. Veillez à toujours bien effectuer un changement devue après avoir exécuté les exemples sur les fonctions CS décrits ci-dessous. C'est pourquoiles modifications faites dans la vue par activation des deux premiers boutons sont perduesaprès activation d'un des autres boutons.



4.8.3 Exemple 3 – Création d'un nouvel objet avec une fonction CS

Cet exemple présente l'utilisation de la fonction CS de l'API de Graphics Designer pour la créationd'un nouvel objet. On crée un nouveau champ E/S. L'exemple est configuré pour l'objet représenté ci-dessous Bouton3 et pour l'événement Souris Clic.




• La première section de code charge la DLL de l'API Graphics Designer. Le fichier pdl_guid.h quicontient la définition d'une constante symbolique utilisée dans cet exemple est ensuite lié auprogramme.

• Il est ensuite défini une variable du type StringszProjectName pour stocker le nom du projet.

• Puis il est défini une variable du type String pour le nom de la vue. A noter la particularité que, à ladifférence des fonctions RT, le nom de vue doit ici contenir l'extension PDL.

• Ensuite, on définit les autres variables qui sont nécessaires. En font entre autres partie une variabledu type GUID servant à définir l'objet à créer.

• La section de code suivante détermine le nom de projet avec la fonction d'APIDMGetRuntimeProject(). Le nom de projet est stocké dans la variable szProjectName. Une erreurest affichée en cas d'échec de la recherche du nom de projet. L'action C est alors interrompue parl'instruction return.

• La section suivante initialise avec la fonction d'API PDLCSGetOleAppPtr() l'API de GraphicsDesigner. En cas d'échec de l'initialisation de l'API de Graphics Designer, cet échec est affiché.L'action C est dans ce cas également interrompue par l'instruction return.

• La section suivante ouvre la vue à traiter avec la fonction d'API PDLCSOpenEx(). L'avant dernierparamètre transmis à la fonction d'API est la variable dwFlags qui est mise à 1. Ceci fait que la vuen'est pas affichée à l'écran. Une erreur est affichée en cas d'échec de la tentative d'ouverture de lavue. L'instruction goto provoque un saut à l'endroit du programme où la liaison à l'API deGraphics Designer va être interrompue.

• Dans la section suivante, la fonction d'API PDLCSNewObjectEx() crée un nouvel objet nomméChampE/S2. Une erreur est affichée en cas d'échec de la création du nouvel objet. L'instructiongoto provoque un saut à l'endroit du programme où la vue précédemment ouverte va être refermée.

• La section suivante stocke la vue avec la fonction d'API PDLCSSave(). Une erreur est affichée encas d'échec de la tentative d'enregistrement. L'instruction goto provoque, comme dans la sectionprécédente, un saut à l'endroit du programme où la vue précédemment ouverte va être refermée.

• On a ensuite programmé avec la fonction de projet ActualizeObjects() une resélection de la vuetraitée.

• La vue précédemment ouverte est refermée par la fonction d'API PDLCSClose(). Cette instructionest précédée d'une marque indiquant la destination de l'instruction goto.

• La fonction d' API PDLCSDelOleAppPtr() interrompt la liaison à l'API de Graphics Designer.Cette instruction est précédée d'une marque indiquant la destination de l'instruction gotoprécédente.

Remarque:Les actions C créées pour les exemples ci-desous sont très semblables à l'action C crééedans l'exemple précédent. On a pour cela, dans les exemples suivants, renoncé à donner desexplications aussi détaillées que celles de l'exemple 4. La description du code y sera limitéeà une présentation d'ensemble du programme.



4.8.4 Exemple 4 – Modification de propriétés avec fonction CS

Cet exemple présente l'utilisation de la fonction CS de l'API de Graphics Designer pour leparamétrage des propriétés d'objets. Il s'agit de modifier la position d'un objet par parmétrage de sespropriétés PositionX et PositionY. L'exemple est configuré pour l'objet représenté ci-dessous Bouton4et pour l'événement Souris Clic.




• La première section de code charge la DLL de l'API Graphics Designer.

• Ensuite, on définit les variables. A la différence de la procédure de l'exemple 1, les noms et lesvaleurs des propriétés à paramétrer sont stockés dans des vecteurs.

• La fonction d'API DMGetRuntimeProject() recherche le nom du projet.

• La fonction d'API PDLCSGetOleAppPtr() initialise l'API de Graphics Designer.

• La fonction d'API PDLCSOpenEx() ouvre la vue à traiter sans l'afficher.

• Les propriétés de l'objet sont paramétrées dans une boucle for avec la fonction d'APIPDLCSSetPropertyEx(). S'il est nécessaire de paramétrer ainsi des propriétés de différents types, ilfaut aussi définir un vecteur à la place de la variable vt. Celui-ci définit alors le type de propriétépour chaque propriété à paramétrer.

• La fonction d'API PDLCSSave() enregistre la vue.

• On a ensuite programmé avec la fonction de projet ActualizeObjects() une resélection de la vue.

• La vue est refermée par la fonction d'API PDLCSClose().

• La fonction d' API PDLCSDelOleAppPtr() interrompt la liaison à l'API de Graphics Designer.



4.8.5 Exemple 5 – Création d'une liaison à une variable avec fonction CS

Cet exemple présente l'utilisation de la fonction CS de l'API de Graphics Designer pour la créationd'une liaison à une variable. On crée pour la propriété Entrée/Sortie Valeur sortie d’un champ E/S une liaison à une variable. L'exemple est configuré pour l'objetreprésenté ci-dessous Bouton5 et pour l'événement Souris Clic.





• Ensuite, on définit les variables nécessaires.




• La section de code suivante remplit les champs de la structure link avec les informations sur laliaison de variable souhaitée.

• La liaison de la variable à l'objet est créée avec la fonction PDLCSSetLink().

• La fonction d'API PDLCSSave() enregistre la vue.

• On a ensuite programmé avec la fonction de projet ActualizeObjects() une resélection de la vue.





4.8.6 Exemple 6 – Listage d'objets avec fonction CS

Cet exemple présente l'utilisation de la fonction CS de l'API de Graphics Designer pour le listage desobjets d'une vue. Pour chaque objet présent dans la vue, l'API appelle une fonction crééespécifiquement à laquelle vont être passées des informations sur l'objet correspondant. Une tellefonction est appelée fonction Callback. L'exemple est configuré pour l'objet représenté ci-dessousBouton6 et pour l'événement Souris Clic.

Fonction de projet ObjectCallback()

• La première section du code lie au programme le fichier apdefap.h, qui contient la définition dutype de structure OBJECT_INFO_STRUCT.

• Le type de la valeur retournée ainsi que les types et le nombre des paramètres transmis sont définispour cette fonction et peuvent être pris dans le kit ODK.

• Un pointeur vers une variable du type OBJECT_INFO_STRUCT est ensuite défini puis initialisé.L'adresse transmise dans le premier paramètre est affectée à ce pointeur. La validité du pointeur estensuite vérifiée.

• Le nom de l'objet dont la variable OBJECT_INFO_STRUCT a été reçue est affiché.





• Ensuite, on définit les variables nécessaires.




• Tous les objets présents dans la vue sont listés avec la fonction d'API PDLCSEnumObjList(). Ilfaut pour cela passer à la fonction d'API l'adresse de la fonction de projet précédemment crééeObjectCallback(). Ce type de fonction est également appelé fonction Callback. Elle est appeléeune fois pour chaque objet présent dans la vue, les données d'un objet étant transmises à chaqueappel.









4.9 Environnement de projet

Pour accéder aux exemples sur l'environnement de projet dans le projet WinCC Project_C_Course,cliquez sur l'icône représentée ci-dessous affichée dans la barre d'outils du navigateur. Les exemplessont configurés dans la vue cc_9_example_11.PDL.

Généralités

Il arrive souvent lors de la programmation d’une action C ou d’une autre fonction qu’il faille indiquerle chemin d’un fichier, le nom de l’ordinateur local, etc. Vous pouvez alors saisir ces valeurs commevaleurs absolues en fonction du projet. Ceci est cependant source de problèmes lors du transfert d'unprojet sur un autre ordinateur. L'environnement de ce système cible est très probablement différent decelui du système source sur lequel le projet a été créé. C'est pourquoi il est recommandé de ne pasutiliser de valeurs absolues pour les chemins, etc. en créant un programme. De telles informationsdoivent être recherchées au runtime. Ce chapitre présente quelques exemples montrant commentaccéder à des informations sur l'environnement de l'ordinateur local. On utilise pour cela l'API deWinCC et l'API de Windows.



4.9.1 Exemple 1 – Recherche de fichier de projet

Cet exemple expose la procédure de recherche d'un fichier de projet WinCC. L'exemple est configurépour l'objet représenté ci-dessous Bouton1 et pour l'événement Souris Clic.


• La première section du code définit une variable bRet du type BOOL.

• Il est ensuite défini une variable du type StringszProjectFile pour stocker le nom du projet. Lalongueur de cette variable doit être définie pour qu'elle puisse stocker le chemin le plus long quipuisse être rencontré.


• La section de code suivante détermine le nom de projet avec la fonction d'APIDMGetRuntimeProject(). Le nom de projet est stocké dans la variable szProjectFile . Vous devezindiquer comme second paramètre l'espace mémoire à réserver pour le nom de projet. Le troisièmeparamètre sert à indiquer l'adresse de la structure d'erreur. La valeur à transmettre est NULL si lesinformations d'erreur ne sont pas nécessaires.

• La valeur retournée par la fonction d'API DMGetRuntimeProject() est ensuite vérifiée.

• Le nom du fichier de projet est alors affiché. Cet affichage est présenté dans la section suivante ducode.





4.9.2 Exemple 2 – Recherche du chemin de projet

Cet exemple expose la procédure de recherche du chemin d'un fichier de projet WinCC. L'exemple estconfiguré pour l'objet représenté ci-dessous Bouton2 et pour l'événement Souris Clic.


• La première section du code définit et initialise une variable bRet du type BOOL.

• Il est ensuite défini une variable du type StringszProjectFile pour stocker le nom du projet. Ondéfinit en outre une variable du type String char* que l'on initialise avec la valeur NULL.



• La valeur retournée par la fonction d'API DMGetRuntimeProject() est ensuite vérifiée.

• La fonction strrchr() recherche ensuite dans le nom du fichier de projet trouvé la position dudernier caractère \. Un 0 est ajouté à la position qui suit le caractère trouvé. Il ne reste alors plusque le chemin du fichier de projet sans le nom du fichier.

• Le nom trouvé pour le chemin de projet est alors affiché. Cet affichage est présenté dans la sectionsuivante.







4.9.3 Exemple 3 – Recherche du chemin d'un projet par fonction de projet

Dans cet exemple, la détermination du répertoire de projet présentée dans l'exemple précédent est icitransposée dans une fonction de projet. L'exemple est configuré pour l'objet représenté ci-dessousBouton3 et pour l'événement Souris Clic.

Fonction de projet GetProjectPath()

• Il faut passer à la fonction de projet une variable du type String dans laquelle le chemin de projettrouvé sera écrit. Le programme appelant doit garantir qu'un espace mémoire suffisant a étéréservé pour cette variable de type String. La valeur retournée par la fonction indique si la fonctiona été exécutée avec succès.

• On a suivi pour la recherche du chemin de projet le même principe que dans l'exemple précédent.

• Il faut maintenant copier le chemin de projet trouvé avec la fonction strcpy() dans la variableString transmise.




• La première section du code définit et initialise une variable bRet du type BOOL.

• Il est ensuite défini une variable du type StringszProjectPath pour stocker le chemin du projet.

• Le chemin du projet est recherché avec la fonction précédemment créée GetProjectPath(). Lavalidité de la valeur retournée par la fonction de projet() est ensuite testée.

• Le nom trouvé pour le chemin de projet est alors affiché.



4.9.4 Exemple 4 – Recherche du répertoire d'installation

Cet exemple expose la procédure de recherche du répertoire d'installation de WinCC. L'exemple estconfiguré pour l'objet représenté ci-dessous Bouton4 et pour l'événement Souris Clic.




• La première section de code définit une variable de type String szProjectFile pour stocker le nomdu fichier de projet.

• On a ensuite défini une variable dmDirInfo pour stocker des informations de chemin. Il s'agit d'unestructure du type DM_DIRECTORY_INFO.


• On définit en outre une variable du type String char* que l'on initialise avec la valeur NULL.


• La fonction d'API DMGetProjectDirectory() remplit la structure dmDirInfo avec les informationsde chemin. Un des chemins contenus dans la variable est le chemin du répertoire GlobalLibrary.Ce chemin est stocké dans le champ szGlobalLibDir. Le répertoire global Library est un sous-répertoire du répertoire d'installation WinCC.

• La première fonction strrchr() recherche le dernier caractère \ dans le chemin déterminé et leremplace par un 0. La deuxième fonction strrchr() recherche à nouveau le dernier caractère \ dansla partie de chemin restée après la coupure. Un 0 est ensuite ajouté à la position suivante.

• Enfin le répertoire d'installation est affiché. Cet affichage est présenté dans la section de codesuivante.





4.9.5 Exemple 5 – Recherche de nom d'ordinateur

Cet exemple expose la procédure de recherche du nom d'ordinateur local. L'exemple est configurépour l'objet représenté ci-dessous Bouton5 et pour l'événement Souris Clic.


• La première section du code lie la DLL Kernel32 au programme. Une seule fonction de cette DLLétant nécessaire, elle est déclarée ici directement. On définit en plus une constante symboliquepour la longueur maximale d'un nom d'ordinateur.

• Il est ensuite défini et initialisé une variable bRet du type BOOL.

• Il est ensuite défini une variable du type StringszComputerName pour stocker le nom d'ordinateur.On a également défini une variable du type DWORD initialisée par la longueur de la variableString préalablement définie.

• La fonction Windows GetComputerNameA() recherche le nom de l'ordinateur local. Celui-ci estécrit dans la variable String transmiseszComputerName.

• La valeur retournée par la fonction Windows GetComputerNameA() est ensuite vérifiée.

• Le nom trouvé pour l'ordinateur est alors affiché.



4.9.6 Exemple 6 – Recherche du nom de l'utilisateur

Ce exemple expose la procédure de recherche de l'utilisateur connecté à WindowsNT. L'exemple estconfiguré pour l'objet représenté ci-dessous Bouton6 et pour l'événement Souris Clic.


• Dans la première section du code, la DLL advapi32 est liée au programme. Une seule fonction decette DLL étant nécessaire, elle est déclarée ici directement. On définit en plus une constantesymbolique pour la longueur maximale d'un nom d'utilisateur.

• Il est ensuite défini et initialisé une variable bRet du type BOOL.

• Il est ensuite défini une variable du type StringszUserName pour stocker le nom de l'utilisateur. Ona également défini une variable du type DWORD initialisée avec la longueur de la variable Stringpréalablement définie.

• La fonction Windows GetUserNameA() recherche le nom de l'utilisateur connecté à WindowsNT.Celui-ci est écrit dans la variable String transmise szUserName.

• La valeur retournée par la fonction Windows GetComputerNameA() est ensuite vérifiée.

• Le nom d'utilisateur trouvé est alors affiché.



4.10 API Windows

Les exemples décrits dans ce chapitre sont configurés dans le projet WinCC Project_C_Course, dansles vues cc_0_startpicture_00.PDL et cc_2_keyboard_01.PDL.

Interface de programmation Windows

Outre l'API WinCC, l'utilisateur peut également utiliser toutes les fonctionnalités de l'API Windowsdans un projet WinCC. Cette API permet un accès pratiquement illimité au système.Les exemples ci-dessous donnent un aperçu de ces fonctionnalités. Ils présentent la procéduregénérale d'utilisation de l'API Windows. Ce n'est cependant pas une présentation exhaustive de l'APIWindows.Les fonctionnalités de l'API Windows sont, comme les fonctions de l'API WinCC, programmées dansdes DLL. Les déclarations des fonctions sont faites dans divers fichiers d'en-tête. L'intégration desDLL se fait d'après le même principe que pour les DLL WinCC. Le code ci-dessous lie par exemple



4.10.1 Exemple 1 – Configuration de propriétés de fenêtre

Cet exemple montre comment modifier les propriétés de fenêtres Windows. L'exemple présente lamodification du titre et de la géométrie de la fenêtre de runtime. L'exemple a été configuré pourl'événement Autres Sélection de la vue de démarrage cc_0_startpicture_00.PDL.

Action C pour vue de démarrage

• Les fonctions Windows utilisées dans l'exemple sont déjà connues du projet WinCC. Il n'est doncplus nécessaire de charger une DLL Windows.

• La première section du code définit une variable du type HWND et l'initialise avec NULL. Cettevariable est appelée un "handle" de fenêtre. On peut se la représenter comme un pointeur vers unefenêtre Windows.

• La fonction Windows FindWindow() permet de rechercher le handle d'une fenêtre Windows enindiquant le titre de la fenêtre. L'indication du titre par défaut de la fenêtre de runtime permet detrouver le handle de la fenêtre.

• La fonction Windows SetWindowText() permet de modifier le titre de la fenêtre de runtime. Dansl'exemple, ce titre est changé en WinCC C-Course.

• La fonction Windows SetWindowPos() permet de définir la position et la taille de la fenêtre deruntime à l'écran. Dans notre exemple, la fenêtre de runtime est placée en haut à gauche de l'écran(position 0/0), ses dimensions étant définies par les valeurs 1024 x 768.

• Les autres instructions du code ci-dessous exécutent des initialisations qui n'intéressent pas cetexemple.



4.10.2 Exemple 2 – Lecture de l'heure système

Cet exemple montre comment lire et afficher l'heure système. L'heure et la date seront affichées dansl'exemple. L'exemple a été programmé dans la vue cc_0_startpicture_00.PDL.

Action C pour texte statique Time

• Dans la dernière section du code, la DLL Kernel32 est liée au programme. Une seule fonction decette DLL étant nécessaire, elle est déclarée ici directement.

• On a défini ensuite une variable sysTime du type SYSTEMTIME. Il s'agit d'une structure servant àstocker l'heure système.

• Une variable de type String szTime est ensuite définie pour stocker l'heure courante au formathh:mm.

• L'action Windows GetLocalTime() écrit l'heure système courante dans la variable sysTime.

• Ensuite, la fonction sprintf() compose l'heure système courante au format hh:mm et la met àdisposition comme valeur retournée. On crée pour la propriété Autres Texte étiquetteune autre action C selon le schéma décrit ici. Celle-ci sert à former la date courante.

• La fonction est exécutée dans le temps de cycle 1s.



4.10.3 Exemple 3 – Exécution de fichiers son

Cet exemple montre comment exécuter des fichiers son. Un fichier son doit être exécuté aubasculement entre les deux barres de navigateur Bases et API Windows et WinCC. L'exemple présentéici a été configuré dans la vue cc_2_keyboard_01.PDL pour le bouton Bouton1.

Fonction de projet CC_PlaySound()

• Dans la première section du code, le fichier apdefap.h est lié au programme. Il est ainsi possibled'appeler d'autres fonctions de projet depuis la présente fonction de projet.

• L'en-tête de la fonction définit une variable de type String comme paramètre à transmettre. Le nomdu fichier son à exécuter doit être passé avec cette variable.

• Dans la dernière section du code, la DLL winmm est liée au programme. Une seule fonction decette DLL étant nécessaire, elle est déclarée ici directement. Deux constantes symboliques sontégalement définies.

• La fonction de projet suppose qu'il existe un sous-répertoire Sound dans le répertoire de projet.Celui-ci contient les fichiers son à utiliser dans le projet. Le chemin du fichier son souhaité estcomposé du chemin du projet, du nom du sous-répertoire et du nom du fichier son transmis, rangédans la variable szSoundPath.

• La fonction Windows PlaySound() exécute le fichier son. Si le fichier son ne peut être exécuté, lafonction Windows MessageBeep() génère un bip.



4.10.4 Exemple 4 – Lancement d'un programme

Cet exemple présente la procédure de lancement d'un programme. On utilise pour cela une fonctionstandard existante qui se sert de l'API Windows. L'exemple a été programmé dans la vuecc_0_startpicture_00.PDL.

Fonction standard ProgramExecute()

• La fonction standard ProgramExecute() retransmet le paramètre passé tout simplement à lafonction Windows WinExec(). La valeur retournée par la fonction WinExec() est retransmise auprogramme appelant de la fonction ProgramExecute(). Le lancement d'un programme s'est déroulécorrectement si la valeur retournée est supérieure à 31.

Action C pour l’objet graphique Execute

• La fonction standard ProgramExecute() lance le programme calc.exe. Il s'agit du programme de lacalculette. Il n'y a pas d'indication de chemin, ceci n'étant pas nécessaire pour les programmes durépertoire Windows.



4.11 Dialogues standard

Pour accéder aux exemples sur les dialogues sandard dans le projet WinCC Project_C_Course,cliquez sur l'icône représentée ci-dessous affichée dans la barre d'outils du navigateur. Les exemplessont configurés dans la vue cc_9_example_12.PDL.

Généralités

La procédure normale de création d'un dialogue dans WinCC consiste à créer une vue WinCC et àl'afficher dans une fenêre de vue. Il est également possible de créer des dialogues standard dans desactions C ou dans d'autres actions. On peut utiliser pour cela des dialogues standard WinCC ou desdialogues standard Windows.Ce chapitre présente l'utilisation de quelques dialogues standard disponibles. Il existe cependant ungrand nombre de dialogues standard qui ne sont pas évoqués ici. Pour s'informer sur ces dialogues,consulter le kit WinCC ODK et la documentation de l'API Windows.



4.11.1 Exemple 1 – Changement de langue

Cet exemple montre comment utiliser le dialogue standard WinCC pour le changement de langue.L'exemple est configuré pour l'objet représenté ci-dessous Bouton1 et pour l'événement Souris

Clic.


• On définit dans la première section les variables utilisées. On définit entre autres un vecteurconstitué des identificateurs des trois langues souhaitées.

• La fonction Windows FindWindow() recherche le handle de la fenêtre de runtime par son titre.Attention: le titre de fenêtre indiqué dans cet exemple de code n'est pas le titre par défaut de lafenête de runtime.

• La fonction d'API DMShowLanguageDialog() affiche le dialogue standard de changement delangue. Un vecteur contenant les ID des langues à afficher dans le dialogue doit être passé à lafonction. La fonction écrit l'identificateur de la langue choisie par l'utilisateur dans la variabletransmise dwGetLocaleID.

• La valeur retournée par la fonction d'API DMShowLanguageDialog() est vérifiée. Cette valeur estentre autres FALSE si l'utilisateur a interrompu le dialogue avec Annuler.

• Le dialogue utilisé ici ne change que la langue du système CS. Pour changer aussi la langue dusystème RT, vous devez utiliser la fonction interneSetLanguage(). L'identificateur de la languechoisie est passé à cette fonction.



Choix d’une langue de dialogue

Le dialogue ci-dessous est affiché à l'exécution de l'action C expliquée ci-dessus.



4.11.2 Exemple 2 – Sélection de variable

Cet exemple montre comment utiliser le dialogue standard WinCC pour la sélection de variable. Lecontenu de la variable sélectionnée dans le dialogue est affiché dans un champ E/S. L'exemple estconfiguré pour l'objet représenté ci-dessous Bouton2 et pour l'événement Souris Clic.


• Dans la dernière section du code, le fichier trigger.h est lié au programme. Ce fichier contient ladéfinition d'une constante symbolique utilisée dans l'exemple.

• On définit dans la section suivante les variables utilisées. On définit entre autres une variabledmVarKey pour stocker des informations sur la variable WinCC à sélectionner dans le dialogue etune variable link pour recevoir les informations sur une liaison à une variable.


• La fonction Windows FindWindow() recherche le handle de la fenêtre de runtime par son titre.



• La fonction API DMShowVarDatabase() ouvre le dialogue de sélection de variable. Lesinformations sur la variable WinCC sélectionnée dans le dialogue sont rangées dans la variabletransmise dmVarName.

• Quand une variable est sélectionnée, son nom est affiché par un texte statique et le contenu de lavariable est affiché dans un champ E/S.

Variables de dialogue




4.11.3 Exemple 3 – Boîte de message d'erreur

Ce exemple montre comment afficher une boîte de message d'erreur. L'exemple est configuré pourl'objet ci-dessous Bouton3, pour l'événement Souris Clic.


• La première section du code définit une variable hWnd du type HWND. La fonction WindowsFindWindow() affecte le handle de la fenêtre de runtime à cette variable.

• La fonction Windows MessageBox() ouvre une boîte de message d'erreur. Il faut indiquer commedeuxième paramètre le texte de l'erreur et comme troisième paramètre le titre de la fenêtre demessage d'erreur. Le quatrième paramètre défnit l'apparence et les réactions de la boîte de messaged'erreur. La boîte de message d'erreur doit être dotée seulement d'un bouton OK (MB_OK); elledoit afficher le symbole d'erreur (MB_ICONSTOP) et être modale (MB_APPLMODAL).L'utilisateur doit acquitter cette boîte de message avant de pouvoir continuer.

• Quand une variable est sélectionnée, son nom est affiché par un texte statique et le contenu de lavariable est affiché dans un champ E/S.

Boîte de message d'erreur

La boîte de message ci-dessous est affichée à l'exécution de l'action C expliquée ci-dessus.



4.11.4 Exemple 4 – Boîte de questions

Cet exemple montre comment afficher une boîte de questions Windows et comment une autre actionpeut être exécutée en fonction du bouton activé par l'utilisateur. L'exemple est configuré pour l'objetreprésenté ci-dessous Bouton4 et pour l'événement Souris Clic.


• La première section du code définit une variable hWnd du type HWND. On a également défini unevariable iRet du type int.

• La fonction Windows FindWindow() recherche le handle de la fenêtre de runtime par son titre.

• La fonction Windows MessageBox() ouvre une boîte de questions. Le quatrième paramètre définitl'apparence et les réactions de la boîte. La boîte de message doit être dotée d'un bouton Oui et d'unbouton OK (MB_OK); elle doit afficher le symbole de question (MB_YESNO) et être modale(MB_APPLMODAL). La valeur retournée par la fonction est rangée dans la variable iRet.

• La dernière section de code exploite la valeur retournée par la fonction. Si le dialogue a été quittéavec Oui, cette valeur est IDYES; s'il a été quitté avec Non, la valeur est IDNO.

Boîte de questions

La boîte de questions ci-dessous est affichée à l'exécution de l'action C expliquée plus haut.



4.11.5 Exemple 5 – Dialogue standard Ouvrir

Cet exemple montre comment utiliser le dialogue standard WinCC pour ouvrir un fichier. L’exempleest configuré pour l'objet représenté ci-dessous Bouton5 pet our l'événement Souris Clic.




• Dans la première section du code, la DLL comdlg32 est liée au programme.

• On définit dans la section suivante les variables nécessaires. On définit entre autres une structureofn de type OPENFILENAME.

• Dans la section suivante, les informations sont écrites dans la variable ofn.

• La variable ofn est passée à la fonction Windows GetOpenFileName(). Celle-ci ouvre un dialoguede sélection de fichier. Le nom du fichier sélectionné par l'utilisateur est stocké dans la variableofn. Le nom du fichier sélectionné est affiché.



Dialogue standard Ouvrir


Autres exemples

Les autres exemples du chapitre présentent, comme l'exemple 5, les dialogues standard de traitementde fichiers.L'exemple 6 utilise le dialogue standard Enregistrer sous... .L'exemple 7 crée la fonction de projet GetFileName() qui doit faciliter la manipulation des dialoguesstandard. Cette fonction peut afficher un dialogue Ouvrir ou un dialogue Enregistrer sous... enfonction d'une constante symbolique transférée. Les constantes symboliques disponibles sontGFN_OPEN et GFN_SAVE.



4.12 Fichiers

Pour accéder aux exemples sur les fichiers dans le projet WinCC Project_C_Course, cliquez surl'icône représentée ci-dessous affichée dans la barre d'outils du navigateur. Les exemples sontconfigurés dans la vue cc_9_example_13.PDL.

Ouvrir fichier

C interprète un fichier comme une collection de caractères sans tenir compte du contenu. Un fichierdoit être ouvert avant de pouvoir être utilisé dans une action C ou dans une autre action. Lorsque letraitement d'un fichier est terminé, celui-ci doit être refermé.Un fichier s'ouvre avec la fonction fopen(). Le code ci-dessous montre l'utilisation de la fonctionfopen().

Pour qu'un fichier puisse être utilisé, un pointeur vers celui-ci doit être défini. C'est à cela que sert letype de données FILE*. La fonction fopen() retourne un pointeur vers le fichier ouvert ou NULL encas d'échec de la tentative d'ouverture du fichier. Le nom du fichier à ouvrir doit être passé avec sonchemin comme premier paramètre à la fonction fopen(). Le deuxième paramètre à passer est le modede traitement pour lequel le fichier doit être ouvert (p. ex. lecture). Les valeurs à indiquer pour lemode figurent dans le tableau ci-dessous.

Mode Description

r Ouvrir un fichier pour lecture. La valeur retournée est NULL si le fichier n'existepas ou en l'absence d'autorisation d'accès en lecture.

w Ouvrir un fichier pour écriture. La valeur retournée est NULL si le fichier n'existepas ou en l'absence d'autorisations d'écriture.

S Ouvrir un fichier pour ajout à la fin. Le fichier est créé s'il n'existe pas. La valeurretournée est NULL s'il ne peut être créé aucun fichier ou s'il n'est pas permisd'écrire dans le fichier.

r+ Ouvrir un fichier pour lecture et écriture en alternance. La valeur retournée estNULL si le fichier n'existe pas ou en l'absence d'autorisations de lecture etd'écriture pour le fichier.

w+ Créer un fichier pour lecture et écriture en alternance. S'il existe déjà, le fichierest supprimé. La valeur retournée est NULL en l'absence d'autorisations pour cesactions.

a+ Ouvrir un fichier pour lecture ou pour ajout à la fin Le fichier est créé s'il n'existepas. La valeur retournée est NULL en l'absence d'autorisations de lecture etd'écriture pour le fichier.



Fermer fichier

Lorsque le traitement d'un fichier est terminé, celui-ci doit être refermé. Un fichier se ferme avec lafonction fclose. Le code ci-dessous montre l'utilisation de la fonction fclose(). Le pointeur vers lefichier à fermer doit être passé à la fonction.

Ecrire dans un fichier et lire un fichier

Il existe pour écrire dans un fichier une fonction semblable à la fonction printf(). Il s'agit de lafonction fprintf(). La fonction fprintf() s'utilise selon le même principe que la fonction printf().Cependant, la sortie ne se fait pas dans une fenêtre de diagnostic Global Script mais dans un fichier.Le premier paramètre attendu par la fonction est un pointeur vers ce fichier. Le code ci-dessousmontre l'utilisation de la fonction fprintf().

La fonction fscanf() permet la lecture d'un fichier. Le fonction fscanf() est structurée comme lafonction fprintf(). On n'indique cependant pas les variables dont les valeurs doivent être écrites dans lefichier, mais les adresses des variables dans lesquelles les contenus du fichier doivent être écrits.



4.12.1 Exemple 1 - Sauvegarder des données

Cet exemple montre comment écrire des données dans un fichier. Les données à écrire doivent êtrepréablablement lues dans des variables WinCC. L'exemple est configuré pour l'objet représenté ci-dessous Bouton1 et pour l'événement Souris Clic.


• On définit dans la première section les variables nécessaires. Il est ensuite défini et initialisé unevariable du type FILE*.

• Le chemin du projet est recherché avec la fonction de projet GetProjectPath().

• Le chemin du fichier à créer est ensuite composé par la fonction strcat(). Ce chemin est transmis àla fonction fopen(). Il doit permettre d'ouvrir ou de créer le fichier souhaité.

• Dans la section suivante, les données à écrire sont lues dans les variables WinCC.

• La fonction fprintf() écrit les données dans le fichier. Le fichier est ensuite refermé.



4.12.2 Exemple 2 - Lire des données dans un fichier

Cet exemple montre comment lire des données depuis un fichier. Les données lues sont écrites dansdes variables WinCC. L'exemple est configuré pour l'objet représenté ci-dessous Bouton2 et pourl'événement Souris Clic.




• Le chemin du fichier à ouvrir est ensuite composé par la fonction strcat(). Ce chemin est transmisà la fonction fopen(). Il doit permettre d'ouvrir le fichier souhaité pour sa lecture.

• La fonction fscanf() lit les données dans le fichier. Le fichier est ensuite refermé.

• Dans la section suivante, les données lues sont écrites dans les variables WinCC.



4.12.3 Exemple 3 - Journalisation

Cet exemple montre comment créer un fichier de journalisation. On crée une fonction de projet quitransmettra un texte de journal. Ce texte sera écrit dans le fichier de journalisation. L'exemple estconfiguré pour l'objet représenté ci-dessous Bouton3 et pour l'événement Souris Clic.

Fonction de projet LogText()

• Une variable de type String ajoutée à la fin du fichier de journal doit être passée à la fonction.



• Le chemin du fichier à ouvrir est ensuite composé par la fonction strcat(). Ce chemin est transmisà la fonction fopen(). Il doit permettre d'ouvrir le fichier souhaité pour ajout.

• La fonction fprintf() écrit le texte de journalisation transmis dans le fichier. La fonction standardGetLocalTimeString() inscrit l'heure système courante devant chaque entrée de journal. Le fichierest ensuite refermé.




• L’action C lit le contenu d'une variable de texte WinCC et le transmet à la fonction de projetprécédemment créée LogText(). Le contenu de la variable texte WinCC est ainsi écrit dans lefichier de journalisation.



4.13 Dynamic Wizard

Pour accéder aux exemples sur Dynamic Wizard dans le projet WinCC Project_C_Course, cliquez surl'icône représentée ci-dessous affichée dans la barre d'outils du navigateur. Les exemples sontconfigurés dans la vue cc_9_example_14.PDL.

Généralités

Dynamik Wizard est un assistant (fonctionnalité complémentaire) de Graphics Designer. Cet assistantaide l'utilisateur dans les phases de configuration répétitives. Il contribue donc à réduire l'effort et lesrisques d'erreurs de configuration.Dynamik Wizard est constitué de plusieurs fonctions Dynamik Wizard. On dispose d'un grand nombrede fonctions Dynamik Wizard. Celles-ci peuvent en outre être complétées par des fonctionsprogrammées par l'utilisateur.

Utilisation de Dynamik Wizard

Dynamik Wizard s'appelle dans Graphics Designer par la commande de menu Affichage → Barresd’outils → Dynamik Wizard. La structure de Dynamik Wizard est représentée ci-dessous. Les diverses

fonctions de Dynamik Wizard sont représentées par des onglets. Un 8GG sur la fonction DynamikWizard souhaitée lance cette fonction.

Une fonction Dynamik Wizard de ce type est composée de plusieurs pages à remplir par l'utilisateur. Ily a une page de démarrage, une page de déclencheurs et diverses pages d'options, ainsi qu'une pagefinale qui regroupe les paramétrages des pages précédentes.



4.13.1 Création de fonctions Dynamik Wizard propres à l'utilisateur

Un éditeur spécifique permet la création de fonctions Dynamik Wizard propres à l'utilisateur. Celui-setrouve dans le répertoire < Répertoire d'installation WinCC >\bin. Il s’agit du programmedynwizedit.exe.Chaque fonction Dynamik Wizard est rangée dans un fichier de script propre. En outre un fichier descipt propre est disponible pour les langues allemand, anglais et français. Les fichiers de script sontrangés dans les répertoires ci-dessous indépendamment de la langue.

< Répertoire d'installation WinCC >\Wscripts\Wscripts.deu< Répertoire d'installation WinCC >\Wscripts\Wscripts.enu< Répertoire d'installation WinCC >\Wscripts\Wscripts.fra

Une fois l'éditeur Dynamik Wizard lancé, vous devez sélectionner dans la barre d'outils la langue pourlaquelle la nouvelle fonction Dynamik Wizard doit être créée.Une fonction Dynamik Wizard doit avoir une structure spécifiée. Nous avons créé pour ce manueldeux exemples de fonctions Dynamik Wizard. Les fichiers de script dans lesquels se trouvent cesexemples sont rangés dans le sous-répertoire créé à cet effet DynWiz du projetWinCCProject_C_Course. Les fichiers de script doivent être copiés dans les répertoires mentionnésci-dessus, dans lesquels les fichiers de script sont rangés par défaut. Vous pouvez alors ouvrir lesexemples dans l'éditeur Dynamik Wizard Editor.

Demo Wizard

Dans le fichier de script Demo.wnf nous avons créé un Dynamik Wizard nommé Demo Wizard. Celuiprésente les fonctions de base qui permettent à l'utilisateur une saisie confortable de données. CeDynamik Wizard n'exécute cependant aucune action.

Dynamiser moteur

Dans le fichier de script Motor.wnf nous avons créé un Dynamik Wizard nommé Dynamiser moteur.Celui-ci a été créé spécialement pour dynamiser un objet utilisateur nommé Moteur et ne peut êtreutilisé pour aucun autre type d'objet. Cet objet utilisateur est rangé dans la bibliothèque de projets duprojet WinCC Project_C_Course et peut, depuis cette bibliothèque, être placé dans une vue. L'objetutilisateur Moteur est lié par le Dynamik Wizard Dynamiser moteur à une structure WinCC de typeMoteur. Plus exactement, diverses actions C et liaisons de variable sont créées pour cette structure. Ona supposé qu'il existe une variable interne WinCC de texte T08i_course_wiz_selected. L'objet demoteur sélectionné peut être caractérisé à l'aide de cette variable.

Compilation de fichiers de script

Après avoir été créée, la fonction Dynamik Wizard doit être compilée à l'aide de la commande demenu Dynamik Wizard Compiler Script puis être enregistrée. Pour pouvoir utiliser la fonctionDynamik Wizard dans Graphics Designer, vous devez l'intégrer à la base de données du DynamikWizard. Ceci se fait avec la commande de menu Dynamik Wizard Lire Wizard Script.Sélectionnez le fichier script à lire dans la boîte de dialogue qui s'ouvre.



4.13.2 Structure d’une fonction Dynamik Wizard

Les diverses sections de code constituant une fonction Dynamik Wizard sont expliquées ci-après.

Liaison des fichiers d'en-tête et des DLL

La liaison des fichiers d'en-tête nécessaires constitue la première partie d'une fonction DynamikWizard. Le plus important des fichiers à lier est le fichier dynamic.h, dans lequel sont déclarées lesfonctions, notamment les fonctions de configuration de l'interface utilisateur du Dynamik Wizard. Ilest en outre possible de lier ici toutes les DLL souhaitées de Windows ou de l'API WinCC.

Définitions spécifiques aux langues

Si la fonction Dynamik Wizard doit être disponible dans plusieurs langues, un fichier de script doitêtre créé pour chaque langue. C'est pourquoi les textes spécifiques aux langues doivent être depréférence définis avant l'écriture du code. Ainsi est-il possible de copier simplement un fichier descript écrit pour une langue particulière. Il suffit alors d'adapter la partie contenant les définitionsspécifiques aux langues.

Liste de propriétés

Il est possible de définir les types d'objets pour lesquels une fonction Dynamik Wizard doit êtreutilisable. Ceci se fait en indiquant une liste de propriétés d'objets. Lorsqu'un objet possède au moinsune des propriétés de la liste, la fonction Dynamik Wizard peut être appliquée à cet objet. Pour lafonction Dynamik Wizard Dynamiser moteur, cette possibilité a été exploitée pour ne la rendreutilisable que pour les objets utilisateur du type Moteur. Ce type d'objet est le seul à proposer lespropriétés Manuel et Sélection. En cas d'utilisation d'une liste de propriétés vide, la fonction DynamikWizard peut être appliquée à tous les types d'objets. La liste de propriétés doit toujours êtredisponibles même si elle est vide.

Fonction d'exécution

La fonction d'exécution est la fonction qui exécute, lorsque le bouton Exécuter est activé, les tâches àproprement parler du Dynamik Wizard. Le nom de cette fonction doit être indiqué dans l'interfacesystème. Une fonction d'exécution très étendue est présentée comme exemple dans le DynamikWizard Dynamiser moteur.



Fonction Info

La fonction Info regroupe les paramétrages saisis par l'utilisateur et affiche ces paramètres dans ladernière page de la fonction Dynamik Wizard. Le nom de cette fonction doit être indiqué dansl'interface système. En cas d'utilisation d'une liste de propriétés vide, la fonction Dynamik Wizard peutêtre appliquée à tous les types d'objets. La liste de propriétés doit toujours être disponibles même sielle est vide.

Interface système

Diverses propriétés de la nouvelle fonction Dynamik Wizard sont définies par l'interface système. Lasignification des divers paramètres est expliquée après l'exemple de code.

• Le premier paramètre définit l'onglet dans lequel la fonction Dynamik Wizard doit apparaître.

• Le deuxième paramètre définit le nom sous lequel la fonction Dynamik Wizard doit apparaître.

• Le troisième paramètre à transmettre est toujours NULL.

• Le quatrième paramètre contient le nom de l'icône à utiliser pour la fonction Dynamik Wizard.

• Le cinquième paramètre permet de transmettre un texte d'aide avec une description plus détailléedes fonctionnalités de la fonction Dynamik Wizard.

• Le sixième paramètre est une liste des noms des fonctions créées pour les pages d'options. Cetteliste doit être terminée par une entrée NULL. Il est possible de créer cinq pages d'options aumaximum.

• Le septième paramètre sert à indiquer le nom de la fonction qui sera appelée à l'activation dubouton Terminer.

• Le huitième paramètre permet d'indiquer le nom de la fonction qui regroupe dans les pagesd'options les paramétrages et les affiche à l'utilisateur avant que celui active le bouton Terminer.



• Le neuvième paramètre sert à indiquer une liste des déclencherurs à entrer dans la page deparamétrage des déclencheurs. Pour les applications les plus fréquentes, des macros sontdisponibles pour remplir cette liste de déclencheurs.

Variables globales

Une variable globale doit être définie pour chacun des paramètres à configurer dans les pagesd'options. Ainsi les paramètres configurés sont connus de toutes les fonctions créées et peuvent y êtreutilisés.

Pages d’options

Une fonction propre doit être créée pour chaque page d'options nécessaire. Les noms de ces fonctionsdoivent être indiqués dans l'interface système.

09.99 Annexe


5 AnnexeL'annexe contient une série de thèmes qui ne sont pas traités directement dans le Manuel deconfiguration.

Annexe 09.99


5.1 Trucs et astuces

Autres exemples de configuration WinCC.

09.99 Annexe


5.1.1 Entrée/Sortie normalisée dans champ E/S

Pour qu'un champ E/S affiche une valeur normalisée ou pour que la valeur saisie soit transmise sousforme normalisée à l'automate, vous devez configurer les actions suivantes:Action agissant sur Propriété "Valeur sortie" d'un champ E/S (important: type "float" souhaité pourafficher des chiffres décimaux)

Action sensible à Evénement "Valeur saisie" d'un champ E/S (la variable "Var1" est une valeur 16 bitsnon signée)

Annexe 09.99


5.1.2 Actions agissant sur des objets à la sélection de vue

Il existe des applications dans lesquelles des actions programmées pour une propriété d'un ou deplusieurs objets d'une vue ne sont exécutées qu'une seule fois à la sélection de vue. Une possibilitéconsiste à formuler une action spécifique à la vue pour l'objet du vue dans EvénementsAutres Sélection de vue. Cette méthode présente cependant les inconvénients que l'action doitagir sur des objets dans la vue et que, par conséquent, les noms d'objet doivent être programmés àdemeure dans l'action. Les objets ne sont plus librement manipulables. Cette solution n'est pasorientée objet.

Il existe un moyen de contourner cette difficulté.

• Définissez une variable interne (p. ex. dummy) qui ne sera ni rafraîchie ni intentionnellementactivée. Sélectionnez sur Modification comme déclencheur de l'action créée pour l'objet. Al'ouverture de la vue dans le runtime, l'action sera exécutée une première fois et ne serait exécutéeà nouveau qu'en cas de modification du contenu de la variable dummy, ce qui, par définition, ne seproduit jamais.

09.99 Annexe


5.1.3 WinCC-Scope

Généralités

WinCC-Scope est un outil d'aide au diagnostic des projets WinCC. Il fournit une grande quantitéd'informations sur le projet activé, mais aussi sur le système informatique utilisé. L'utilisation deWinCC-Scope nécessite un navigateur web tel que Internet Explorer. Le protocole réseau TCP/IP doiten outre être installé.

Démarrage et manipulation

Si vous avez installé WinCC, WinCC-Scope a également été installé par défaut. Vous devez avantd'utiliser WinCC-Scope lancer le programme WinCCDiagAgent.exe. Celui-ci se trouve dans lerépertoire Siemens\WinCC\WinCCScope\bin. Il s'agit d'un serveur HTTP simple. Vous pouvez ensuiteactiver Scope par le menu de démarrage. Dans la page de démarrage, le renvoi How to use the newDiagnostics Interface permet d'accéder à une page contenant une description générale de lamanipulation du composant WinCC-Scope. Cliquez sur http://localhost pour démarrer Scope. La listede la fenêtre de gauche permet d'appeler des informations de nature très diverse. System Info affichedes informations générales sur la configuration utilisée; WinCC Info affiche des informations sur leprojet WinCC activé.

Annexe 09.99


5.1.4 Accs la base de donnes

5.1.4.1 Accès à la base de données depuis Excel/MSQuery

La description ci-dessous de l'accès à la base de données WinCC se réfère à Microsoft® Excel 97avec SR-1.

Accès depuis Excel/MSQuery

Etape Procédure: Accès depuis Excel/MSQuery

1 Ouvrez Excel. Cliquez sur les commandes de menu Données Donnéesexternes Créer nouvelle requête... pour ouvrir le dialogue Sélectionnersource de données de MSQuery.

09.99 Annexe



Sélectionnez dans l'onglet Bases de données l'entrée Source de données. Créezune nouvelle source de données avec le bouton OK.

2 Entrez dans le dialogue Créer nouvelle source de données le nom de la nouvellesource de données. Celui-ci ne doit pas être nécessairement identique au nom dela base de données WinCC. Sélectionnez le pilote Sybase SQL Anywhere 5.0.

Cliquez sur le bouton Lier... pour ouvrir le dialogue Connect to SQL Anywheredans lequel vous devez saisir les informations nécessaires au pilote. Entrezcomme User ID dba et comme Password sql. Sélectionnez la base de données àutiliser avec le bouton Browse.

Terminez la saisie par OK.

Annexe 09.99



3 S'il n'a pas encore été configuré de source de données pour la base de donnéessélectionnée, l'alarme Nom de source de données pas trouvé et aucun pilotestandard indiqué est affichée.

Acquittez cette alarme et cliquez une nouvelle fois sur le bouton Lier....Sélectionnez dans le dialogue Sélectionner source de données l’onglet Source dedonnées ordinateur. La liste des sources de données contient déjà la base dedonnées du système de configuration et la base de données du runtime du projetWinCC actuellement exécuté. Le nom de ces sources de données commence parla chaîne de caractères CC_ suivie du nom du projet. Le nom de la source dedonnées correspondant à la base de données du runtime se termine par R.

Si vous devez cependant utiliser une base de données WinCC quelconque, vousdevez créer pour celle-ci une source de données. On utilise pour cela le boutonNouveau. Dans la première page de l'assistant alors affiché Créer une nouvellesource de données, sélectionnez l'option Source de données utilisateur, puisquittez cette page par Suivant. Dans la page suivante, sélectionnez le piloteSybase SQL Anywhere 5.0, puis quittez cette page par Suivant. Quittez la dernièrepage par Terminer.

Dans le dialogue SQL Anywhere ODBC Configuration alors ouvert, saisissez lesinformations requises par le pilote. Entrez comme User ID dba et commePassword sql. Sélectionnez la base de données à utiliser avec le bouton Browse.

Quittez le dialogue par OK.

09.99 Annexe



Sélectionnez la nouvelle source de données créée dans le dialogue Sélectionnersource de données, puis quittez le dialogue par OK.

Confirmez le dialogue affiché Connect to SQL Anywhere.

Vous pouvez aussi configurer en amont la source de données dans le panneau deconfiguration. Pour cela, ouvrez dans le panneau de configuration le Gestionnairede sources de données ODBC. Cliquez sur le bouton Ajouter pour ouvrirl’assistant Créer nouvelle source de données.

4 Quittez le dialogue Créer nouvelle source de données par OK.

Dans le dialogue Sélectionner source de données, sélectionnez la source dedonnées qui vient d'être créée et quittez le dialogue par OK.

La première page de l'Assistant Query affiche tous les tableaux et toutes lescolonnes disponibles. Sélectionnez les tableaux et colonnes souhaités et quittez lapage par Suivant. Les pages suivantes permettent d'activer des filtres de donnéeset de paramétrer l'ordre de tri de celles-ci. Vous paramétrez dans la dernière pagesi les données doivent être ensuite traitées dans Excel ou dans MSQuery. Quittezle dialoguer par Terminer.

5 Le dialogue Retouner données externes à Excel sert à définir le positionnementdes tableaux à ajouter. Il permet également de paramétrer les propriétés de la zonede données externes. Quittez le dialogue par OK.

5.1.4.2 Accès à la base de données depuis Access

La description ci-dessous de l'accès à la base de données WinCC se réfère à Microsoft® Access 97avec SR-1.

Accès depuis Access

Etape Procédure: Accès depuis Access

1 Ouvrir ou créer une base de données Access. Cliquez sur les commandes de menuFichier Données externes Importer... pour ouvrir le dialogueImporter. Sélectionnez comme type de données l'entrée de la liste Bases dedonnées ODBC.

Le dialogue Source de données est ouvert automatiquement. Dans l'onglet Sourcede données ordinateur, sélectionnez une source de données. La liste des sourcesde données contient déjà la base de données du système de configuration et labase de données du runtime du projet WinCC actuellement exécuté. Le nom deces sources de données commence par la chaîne de caractères CC_ qui est suiviedu nom du projet. Le nom de la source de données correspondant à la base dedonnées du runtime se termine par R.

2 Si la base de données WinCC souhaitée ne figure pas déjà dans la liste, vousdevez la créer avec le bouton Nouveau.

Dans la première page de l'assistant alors affiché Créer une nouvelle source dedonnées, sélectionnez l'option Source de données utilisateur, puis quittez cettepage par Suivant. Dans la page suivante, sélectionnez le pilote Sybase SQLAnywhere 5.0, puis quittez cette page par Suivant. Quittez la dernière page parTerminer.

Annexe 09.99


Etape Procédure: Accès depuis Access

Dans le dialogue SQL Anywhere ODBC Configuration alors ouvert, saisissez lesinformations requises par le pilote. Entrez comme User ID dba et commePassword sql. Sélectionnez la base de données à utiliser avec le bouton Browse.

Quittez le dialogue par OK.

Sélectionnez la nouvelle source de données créée dans le dialogue Sélectionnersource de données, puis quittez le dialogue par OK.

3 Vous pouvez choisir les tables de base de données souhaitées dans le dialogueImporter objets. La commande OK insère ces tables dans la base de donnéesAccess.

5.1.4.3 Accès à la base de données depuis ISQL

ISQL permet d'accéder directement à la base de données WinCC. Ceci est cependant aux risques etpérils de l'utilisateur, l'édition et la suppression de tables pouvant affecter la cohérence et l'intégritédes données de configuration.

09.99 Annexe


Accès depuis ISQL

Etape Procédure: Accès depuis ISQL

1 Lancement de ISQL.EXE dans le répertoire Siemens\Common\sqlany.

Le dialogue Interactive SQL Logon est affiché. Entrez comme User ID dba etcomme Password sql. Lorsque vous validez par OK, le programme est liéautomatiquement à la base de données WinCC actuellement ouverte, précisémentà la base de données CS. Pour accéder à une autre base de données, p. ex. à labase de données de runtime, utilisez la commande de menu Command Connect. Dans le dialogue affiché, saisissez les mêmes valeurs pour User ID etPassword. Entrez comme fichier de base de données la base de données souhaitéeavec son chemin complet.

2 Vous ne pouvez saisir dans la fenêtre Command que des clauses SQL, quis'exécutent avec le bouton Execute.

Ci-après quelques exemples de clauses SQL:

• select * from systable : affiche tous les noms de table

• select * from > : affiche le contenu de la table dont le nom est >

• unload tabele > to > : exporte la table dont le nom est > dans le fichier dont lenom est >

• drop table > : supprime la table dont le nom est >

5.1.4.4 Accès à la base de données depuis WinCC-Scope

Accès depuis WinCC-Scope

Etape Procédure: Accès depuis WinCC-Scope

1 Avant de lancer WinCC-Scope par le menu de démarrage, vous devez lancerl'application WinCCDiagAgent.exe dans le dossierSiemens\WinCC\WinCCScope\bin.

2 Dans la page de démarrage, le renvoi How to use the new Diagnostics Interfacepermet d'accéder à une page contenant une description générale de lamanipulation du composant WinCC-Scope.

Cliquez sur http://localhost pour démarrer Scope.

3 Vous pouvez sélectionner diverses fonctions dans une liste affichée dans la partiegauche.

• Database contient des informations générales sur la base de données WinCC.

• Database Query peut afficher des tables d'une base de données. La DataSource paramétrée est la base de données CS du projet WinCC actuellementouvert. Le nom de ces sources de données commence par la chaîne decaractères CC_ qui est suivie du nom du projet. Le nom de la source dedonnées correspondant à la base de données du runtime se termine par R.D'autres sources de données peuvent cependant être affichées.

• SQL Query permet d'appliquer des clauses SQL à une source de données àsélectionner. Il est cependant conseillé de ne traiter la base de données WinCCpar des clauses SQL que si vous possédez de très bonnes connaissancessystème. Des exemples de clauses SQL sont présentés dans la page précédente"Accès à la base de données depuis ISQL".

Annexe 09.99


5.1.4.5 Exportation depuis une base de données par actions C

L'exportation de données peut être activée depuis une vue du runtime WinCC. Vous pouvez pour celalancer une clause SQL interactive avec ligne de commande par ProgramExcecute. L'action à exécuterest enregistrée dans un fichier de commande (par exemple: archiv.sql).

Action C p. ex. pour bouton

• La variable path contient le chemin du programme ISQL.exe ainsi que les paramètres d'appel de ceprogramme.

• La variable parameters contient les paramètres à saisir dans le dialogue Interactive SQL Logonpour la connexion à la base de données. Il s'agit des paramètres:

• UID (User ID): DBA

• PWD (Password): SQL

• DBN (Data Base Name): nom de la source de données ODBC. Le nom de cette source de donnéescommence par la chaîne de caractères CC_ qui est suivie du nom du projet, de la date et de l'heurede création du projet. Le nom de la source de données correspondant à la base de données duruntime se termine par R. Le projet étant activé, vous pouvez rechercher ce nom par Panneau deconfiguration ODBC onglet DSN utilisateur.

• La variable action indique que les clauses SQL listées dans le fichier archiv.sql doivent êtreexécutées.

• Les instructions sont regroupées dans ExportArchive et exécutées par la fonctionProgramExecute().

Remarqu:Si l'exportation doit se faire depuis une base de données autre que l'une des deux bases de données deprojet, vous devez indiquer à la place du paramètre DBN le paramètre DBF, le fichier de base dedonnées avec le chemin de la base de données. Ce chemin ne fonctionne cependant pas pour la basede données activée.

09.99 Annexe


Contenu du fichier: archiv.sql).

• Sélectionnez dans la base de données ouverte l'archive de valeur de mesurepde#hd#ProcessValueArchive#Analog et exportez cette archive dans le fichier ASCII archiv.txtpar la commande output.

5.1.4.6 Sélections de base de données

La commande Select précédemment décrite du fichier de commande sert à sélectionner des tables. Desparamètres supplémentaires permettent de sélectionner des sous-ensembles de ces tables, qui sontensuite exportés avec la commande output. Nous présentons ci-dessous quelques exemples sur cethème.

Sélection d'une plage de temps

Sélection à partir d'un instant

Sélection d'une valeur de process avec et sans tri

Sélection avec choix des colonnes T (Time) et V (Value) valeur de process

Annexe 09.99


5.1.5 Couplage série

Les paramétrages ci-dessous sont nécessaires pour établir une connexion série:

Paramétrages CP525:

Message: Nom paramètre CP525: P3964R

Procédure: COMPOSANT: RK Version: 01

Vitesse en bauds: 9600 Longueur en caractères: 8

Nombres des bits d'arrêt: 1 Priorité: FAIBLE

Parité: PAIRE

Il faut, dans l'automate, une fois SYNCHRON dans le branchement de programme de démarrage pourle processeur CP525 et les primitives SEND/RECEIVE-ALL dans le programme cyclique.

Paramétrages WinCC:

Pour optimiser la liaison, un des deux partenaires doit de préférence avoir la priorité haute. Il estjudicieux que ce soit WinCC.

09.99 Annexe


5.1.6 Tableaux des couleurs

Les valeurs de couleur sont composées à partir d'une large palette.Les 16 couleurs de base sont:

Couleur Valeur couleur (Hexa) Constante symbolique

Rouge 0x000000FF CO_RED

Rouge foncé 0x00000080 CO_DKRED

Vert 0x0000FF00 CO_GREEN

Vert foncé 0x00008000 CO_DKGREEN

Bleu 0x00FF0000 CO_BLUE

Bleu foncé 0x00800000 CO_DKBLUE

Cyan 0x00FFFF00 CO_CYAN

Cyan foncé 0x00808000 CO_DKCYAN

Jaune 0x0000FFFF CO_YELLOW

Jaune foncé 0x00008080 CO_DKYELLOW

Magenta 0x00FF00FF CO_MAGENTA

Magenta foncé 0x00800080 CO_DKMAGENTA

Gris clair 0x00C0C0C0 CO_LTGRAY

Gris 0x00808080 CO_DKGRAY

Noir 0x00000000 CO_BLACK

Blanc 0x00FFFFFF CO_WHITE

La constante symbolique est prédéfinie par #define extern.Les autres couleurs s'obtiennent par combinaison de valeurs intermédiaires de la palette.Lorsque vous créez des modifications de couleur dans le dialogue de dynamisation et que vous voulezensuite traiter les données configurées par des actions C, vous pouvez également lire les valeurs decouleur qui sont cependant au format décimal.

Annexe 09.99


5.2 Documentation du systme d’alarmes S5

Fonctions du systèmes d'alarmes S5

La présente documentation décrit les fonctions et propriétés du logiciel Simatic S5:Système d'alarmes S5Ce logiciel assure l'acquisition chronologique d'alarmes binaires ainsi que leur traitement etenregistrement intermédiaire. Il fournit, dans l'environnement SIMATIC S5, les fonctionnalitéslogicielles nécessaires à la réalisation de la fonction d'acquisition chronologique des alarmes dusystème WinCC.

Le principe de fonctionnement du logiciel peut se décrire ainsi: il surveille l'état binaire du signal desalarmes que l'utilisateur met à la disposition du système d'alarmes S5 dans une interface d'alarme. Enprésence d'un changement d'état du signal, l'alarme est identifiée par son numéro et horodatée. Cesdonnées sont complétées (si l'utilisateur l'a configuré) par une variable de process 32 bits et par uneétiquette alphanumérique de contrat/charge. Si nécessaire, le bloc d'alarmes ainsi constitué est stockédans un tampon cyclique. Ce stockage en tampon des données d'alarmes est toujours nécessairelorsqu'il surgit plus d'alarmes par unité de temps que le bus ne peut en transmettre au système WinCC.Cette fonction de tamponnage réalise un découplage dans le temps entre l'acquisition chronologiquedes alarmes dans SIMATIC S5 et le système d'alarmes WinCC de niveau supérieur ainsi que letraitement en temps réel des alarmes.

Les blocs d'alarmes créés par le système d'alarmes S5 sont mis à la disposition du programmeutilisateur S5 dans un bloc de données interface. Un logiciel de couplage S5 à réaliser par l'utilisateurtransfère ces données par le réseau local (par exemple SINEC H1) au système d'alarmes WinCC deniveau supérieur. Celui-ci dispose de vastes fonctions de traitement des alarmes telles quevisualisation, archivage, etc.

Le système d'alarmes S5 est configuré par l'utilisateur dans un bloc de données interface (DB système80). L'utilisateur définit dans ce bloc les conditions générales système de fonctionnement du systèmed'alarmes. C'est ici que sont définies les espaces mémoire utilisés par le système d'alarmes S5, le typeet le volume des alarmes à traiter ainsi que la division des zones d'adresse occupées.Le présent chapitre décrit l'emploi du système d'alarmes S5 dans l'environnement SIMATIC S5. Ildonne à l'utilisateur une vue générale des blocs de données et blocs de fonctions utilisés par le logicielainsi que de l'espace mémoire nécessaire. Cette présentation sera suivie par une description détailléede toutes les interfaces de données existant entre le système d'alarmes S5 et le programme utilisateurS5. Le lecteur trouvera un exemple de configuration lui facilitant sa familiarisation avec lamanipulation du système d'alarmes S5.

09.99 Annexe


5.2.1 Liste des blocs du logiciel

Le logiciel SIMATIC S5 et les exemples se rapportant au présent manuel se trouvent sur le CD-ROM,dans le fichier WINCC1ST.S5D.Ce fichier contient les blocs de données et blocs fonctionnels du système d'alarmes S5:

FB Nom Taille Fonction

FB 80 SYSTEMFB 1114 Alarmes au fil de l'eau

FB 81 ANLAUFFB 135 Démarrage et initialisation des alarmes au fil de l'eau

FB82 PCHECK 574 Bloc appelé par FB 81

FB 83 MBLOCK 699 Bloc appelé par FB 80

FB 84 SCHREIB 94 Bloc appelé par FB 80

FB 87 VOLL 87 Bloc appelé par FB 80

DB 80 System DB 512 Paramétrage du système d'alarmes

Total 2703

Tableau 1

L'espace mémoire minimum nécessaire dépend de la configuration du système d'alarmes S5. Les blocsde données suivants sont toujours nécessaires en plus des autres.

Tampon cyclique (mini) 2 DB = 1024 octets

Bloc de données interface vers WinCC 1 DB = 512 octets

Prévoir 512 autres octets pour chaque bloc de données d'offset et de paramètres.Le mode de calcul de la taille exacte des blocs de données d'offset sera expliqué au chapitre Structuredu bloc de données d'offset. Le mode de calcul de la taille des blocs de données de paramètres estexpliqué au chapitre Structure du bloc de données de paramètres.

Annexe 09.99


5.2.2 Prérequis matériels

Les blocs fonctionnels indiqués dans le tableau 1 pour le système d'alarmes S5 supposent, pour êtrecorrectement exécutés, le matériel suivant:

API CPU

AG 115U CPU 944 * , CPU 945

AG 135U CPU 928B

AG 155U CPU 946/ 947, CPU 948

Tableau 2

* seule la CPU 944 à deux interfaces PG possède une heure systèmeCes CPU possèdent une heure interne et sont donc capables de fournir la date et l'heure actuelle pourla formation des blocs d'alarme.Un télégramme de date et d'heure actuelles est écrit cycliquement dans la CPU de l'automateSIMATIC S5 par chaque canal WinCC créé. Le bloc fonctionnel FB 86 : MELD:UHR synchronisel'heure interne de l'automate SIMATIC S5 avec celle du système WinCC.

09.99 Annexe


5.2.3 Intgration du systme d’alarmes S5 au programme utilisateur SIMATIC S5

Vous devez effectuer les opérations suivantes pour intégrer le logiciel SIMATIC S5 dans leprogramme utilisateur SIMATIC S5:Vous devez tranférer tous les blocs du Tableau 1 du fichier WinCCST.S5D dans l'API correspondant.Si les blocs de communication ne sont pas déjà implémentés par défaut ou ne se trouvent pas encoredans l'automate, vous devez les transférer dans l'API correspondant.

Etape Procédure: Intégration du système d'alarmes

1 Vous devez tranférer tous les blocs du Tableau 1 du fichier WinCCST.S5D dansl'API correspondant.

2 Si les blocs de communication ne sont pas déjà implémentés par défaut ou ne setrouvent pas encore dans l'automate, vous devez les transférer dans l'APIcorrespondant.

3 Paramétrez le bloc de données DB 80 conformément aux instructions du chapitreParamétrage de DB80.

4 Paramétrez les blocs de données du bloc interface, du tampon cyclique, de l'offsetd'alarme et éventuellement les paramètres d'alarme conformément auxinstructions du chapitre Paramétrage des blocs de données.

5 Initialisez les blocs de données d'offset pour les différents types d'alarmesconformément aux instructions du chapitre Initialisation des blocs d'alarmesd'offset.

6 Définissez les variables de process, l'étiquette de contrat et de charge pour lesdifférentes alarmes dans le programme utilisateur.

7 Appelez les blocs suivants dans les OB de démarrage (OB 20, OB 21, OB 22):

• SPA HTB : SYNCHRON (le bloc de communication de la CPUcorrespondante)

• SPA FB 81 : ANLAUFFB

8 Appelez les blocs suivants dans OB 1:

• pour le traitement cyclique des alarmes SPA FB 80 : SYSTEMFB

• un bloc fonctionnel créé par l'utilisateur pour transférer les blocs d'alarmesvers le système WinCC de niveau supérieur.

9 Ajoutez d'autres fonctionnalités selon les instructions des chapitres suivants:

• la synchronisation de la date et de l'heure par le bloc FB 86 : MELD:UHRTableau 3

Annexe 09.99


Figure 1

Description générale du système d'alarmes S5Les composants suivants du système d'alarmes S5 doivent être décrits:

• bloc de données d'offset

• bloc de données de paramètres

• bloc d'alarmes

• tampon cyclique

• bloc interface

• bloc de données systèmeRelation entre les différents composants:

Figure 2

Pour que le système d'acquisition des alarmes puisse surveiller et acquérir les alarmes, celles-cidoivent être configurées dans les blocs de données correspondants. On distingue quatre typesd'alarmes:

09.99 Annexe


Type Définition types d'alarmes

1 Alarme sans paramètres

2 Alarme avec variables de process (2 DW)

3 Alarme avec variables de process (2 DW) et étiquette de contrat/charge (3 DW)

4 Alarme avec variables de process (2 DW) et étiquette de contrat/charge (3 DW) etréserve (3 DW)

Vous pouvez paramétrer globalement un horodatage pour la formation des blocs d'alarmes du systèmed'alarmes. Lorsque l'horodatage fait défaut, le système WinCC complète les blocs d'alarmes en leurajoutant les informations correspondantes.

5.2.3.1 Structure du bloc de données d'offset

Le bloc de données d'offset présente la même structure pour les quatre types d'alarmes. Vousparamétrez l'adresse de bloc de données correspondante pour chaque type d'alarme dans le bloc dedonnées système DB 80. Bloc de données d'offset pour le type d'alarme correspondant:

DW Contenu Affectation

DW 0 Libre En-tête

DW 1 Numéro d'alarme de base

DW 2 Adresse du dernier bloc d'état de signal

DW 3 Libre

DW 4 Etats de signal des alarmes - No bit:

15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

Bloc d'états de signal 1

DW 5 Bits d'état de repos

DW 6 Bits d'acquittement

DW 7 Mémentos de front de signal


15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0



DW 10 Bits d'acquittement

DW 11 Mémentos de front de signal


15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0



Tableau 5

Nous décrivons ci-après:

• Numéro d'alarme de base

• numéro d'alarme d'offset

• bloc d'états de signal

• Adresse du dernier bloc d'état de signal

• états de signal

• Bits d'état de repos

Annexe 09.99


5.2.3.2 Numéro d'alarme de base

Un numéro d'alarme servant à identifier les alarmes qui surviennent est affecté à chaque alarme. Cenuméro d'alarme est constitué du numéro d'alarme de base et d'un numéro d'alarme d'offset.Vous devez saisir pour chaque type d'alarme utilisé un numéro d'alarme de base différent. Les alarmesde ce type sont identifiées par le numéro d'alarme d'offset et le numéro de série attribué à partir de cenuméro d'alarme de base.Le numéro d'alarme de base d'un type d'alarme se définit dans le mot de données DW 1 du bloc dedonnées d'offset correspondant.

Cas particulier

Vous pouvez utiliser deux blocs de données d'offset pour le type d'alarme 1. Pour la numérotationcontinue des alarmes de ce type, vous devez entrer comme numéro d'alarme de base du deuxième blocde données d'offset le numéro d'alarme de base du premier bloc de données d'offset plus le nombred'alarmes qu'il contient (1008 alarmes).Calcul du numéro d'alarme:Numéro d'alarme = Numéro d'alarme de base + Numéro d'alarme d'offset

Exemple:

Calcul Description

Numéro d'alarme donné: Type d'alarme 1, numérotation continue des alarmes,début: numéro d'alarme 10000

Numéro d'alarme recherché: Numéro d'alarme de base des deux blocs de donnéesd'offset

10000 Numéro d'alarme de base du premier bloc de donnéesd'offset

10000 + 1008 = 11008 Numéro d'alarme de base du deuxième bloc de donnéesd'offset

5.2.3.3 Numéro d'alarme d'offset / Etats de signal des alarmes

Les états de signal des alarmes se trouvent dans les blocs de données d'offset du type d'alarmecorrespondant à la position de bit de numéro d'alarme d'offset.Le numéro d'alarme d'offset d'une alarme commence aux bits 0-15 du DW 4. La numérotationcontinue se fait par pas de 4 (DW8, DW12, ...).

Bloc d'états signal Bloc d'états signalcommençant au mot dedonnées

Numéro de bits 0 - 15correspondant au numéro d'alarmed'offset

1 4 0 - 15

2 8 16 - 31

3 12 32 - 47

4 16 48 - 63

... ...

62 248 976 - 991

63 252 992 - 1007

Tableau 6

09.99 Annexe


Calcul du numéro d'alarme d'offset:

Numéro d'alarme d'offset = Numéro d'alarme - Numéro d'alarme de base

Numéro d'alarme d'offset = (Mot de données / 4 -1) * 16 + No bit (0-15)

Numéro d'alarme d'offset = (Bloc d'états signal - 1) * 16 + No bit (0-15)

Calcul de DB-DW, No bit à partir du numéro d'alarme d'offset:

Bloc de données = Bloc de données d'offset

Mot de données = (Numéro d'alarme d'offset / 16+ 1) * 4

No bit = Numéro d'alarme d'offset % 16

Le mot de données peut être supérieur à 252 pour le type d'alarme 1. Dans ce cas:

Bloc de données = Bloc de données d'offset + 1

Mot de données = Mot de données - 252

No bit = No bit

Exemple:1

Numéro d'alarme donné: DW 248, bit 7, Numéro d'alarme de base = 10000

Numéro d'alarme recherché: Numéro d'alarme

Bloc d'états signal = 248 / 4

= 62

Numéro d'alarme d'offset = (Bloc d'états signal - 1) * 16 + No bit

= (62 - 1) * 16 + 7 = 983

Numéro d'alarme = Numéro d'alarme de base + Numéro d'alarme d'offset

= 10000 + 983 = 10983

Le numéro d'alarme souhaité est 10983.

Exemple: 2

Numéro d'alarme donné: Type d'alarme avec deux blocs de données d'offset, Numéro d'alarme = 12000, Numéro d'alarme de base = 10000

Numéro d'alarme recherché: DB, DW, No bit


= 12000 - 10000 = 2000

No bit = Numéro d'alarme d'offset % 16 = 0

Mot de données = (Numéro d'alarme d'offset / 16+ 1) * 4

= (2000 / 16 + 1) * 4 = 504

Le mot de données a une taille supérieure à 252.

Bloc de données = Bloc de données d'offset + 1

Mot de données = 504 - 252 = 252

No bit = 0

Le numéro d'alarme 12000 se trouve dans le mot de données 252, bit numéro 0, du deuxième bloc dedonnées d'offset du premier type d'alarme.

Annexe 09.99


5.2.3.4 Bloc d'états signal

Le premier bloc d'états de signal commence à l'adresse de mot de données 4. Les blocs d'états designal suivants suivent à une distance constante de 4 mots de données (DW 8, DW 12, ...).Voir à ce sujet également Tableau 5 et Tableau 6.63 blocs d'états de signal (blocs d'états de signal 1 à 63) sont possibles pour chaque bloc de donnéesd'offset.Un bloc d'états de signal contient 16 états de signal. Il en résulte 63 * 16 = 1008 alarmes possiblesdans un bloc de données d'offset.

Structure du bloc d'états de signal

DW Numéro bit 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

1 Etats signal 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

2 Etats repos 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

3 Bits d'acquittement 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

4 Mémentos de front de signal 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Tableau 7Le présent chapitre contient d'autres informations sur ces quatre états binaires.Calcul d'un bloc d'états de signal:

Bloc d'états signal = (Numéro d'alarme d'offset / 16) + 1

Bloc d'états signal = Mot de données / 4

Calcul du mot de données par lequel le bloc d'états de signal commence:Premier mot de données du bloc d'états de signal = Bloc d'états de signal * 4

5.2.3.5 Adresse du dernier bloc d'état de signal

Le nombre des alarmes possibles d'un type d'alarme est déterminé par la saisie de l'adresse DW, dudernier bloc d'états de signal occupé par des alarmes.Calcul du dernier bloc d'états de signal:Dernier bloc d'états de signal = Nombre d'alarmes nécessaires de ce type d'alarme / 16

Un nombre d'alarmes supérieur à 1008 est possible pour le type d'alarme 1. Dans ce cas:

1er DB d’offset:

Dernier bloc d'états de signal = 63

Adresse du dernier bloc d'état de signal= 63 * 4 = 252

09.99 Annexe


2ème DB d'offset:

Dernier bloc d'états de signal = (Nombre d'alarmes nécessaires pour ce type d'alarme - 1008) / 16

Calcul de l'adresse DW du dernier bloc d'états de signal:

Adresse DW du dernier bloc d'états de signal = Dernier bloc d'états de signal * 4

Exemple:

Données: 1030 alarmes du type d'alarme 1

1er DB d’offset:

Adresse du dernier bloc d'états de signal = 63 * 4 = 252

2ème DB d'offset:

Nombre d'alarmes nécessaires - 1008 = 1030 - 1008 = 22

(Nombre d'alarmes nécessaires - 1008) /16

= 22 / 16 = 1

(Nombre d'alarmes nécessaires - 1008)% 16

= 22 % 16 = 6

Dernier bloc d'états de signal * = 2

Adresse du dernier bloc d'états de signal = 2 * 4 = 8

5.2.3.6 Etats de signal

Position: 1er mot de données du bloc d'états de signal (voir Tableau 5).Il incombe à l'utilisateur de bien entrer les états de signal des différentes alarmes dans les mots dedonnées prévus à cet effet des blocs de données d'offset. Ceci peut être réalisé par un rafraîchissementcontinu des signaux pendant le déroulement du process par le programme de l'automate.

5.2.3.7 Etats de repos

Position: 2ème mot de données du bloc d'états de signal (voir Tableau 5).On entend par état de repos d'un signal son niveau à l'état de fonctionnement passif. On définit ainsi siun signal (alarme) doit être actif à l'état bas ou à l'état haut. Cette information est nécessaire pour voirsi une alarme est une alarme "arrivée" ou "partie".Une alarme dont la modification d'événement possède l'état inversé de repos est une alarme "arrivée".L'état de modification par événement d'une alarme "partie" est le même que l'état de repos de l'alarme.Les états de repos des alarmes doivent être entrés par l'utilisateur aux positions correspondantes.

Annexe 09.99


5.2.3.8 Bits d’acquittement

Position: 3ème mot de données du bloc d'états de signal (voir Tableau 5).Les bits d'acquittement ne sont pas configurés mais exploités par le programme en cours d'exécution.Les alarmes sont acquitées directement par le PC de supervision en fonction de la philosophied'acquittement. Le PC envoie ces acquittements à l'automate programmable correspondant avec lesalarmes du système d'acquisition d'alarmes intégré configurées.Le bit d'acquittement correspondant est mis à 1 par le système d'alarmes S5 pendant la durée d'uncycle de l'automate programmable.Le programme d'application doit exploiter cette information en conséquence.

5.2.3.9 Mémentos de front

Position: 4ème mot de données du bloc d'états de signal (voir Tableau 5).Les mémentos de front servent à signaler les modifications d'événement survenues (modificationd'alarme). Ils ne sont pas configurés mais exploités pendant l'exécution du système d'alarmes S5.

5.2.3.10 Structure du bloc de données de paramètres

Vous devez outre un bloc de données d'offset paramétrer, pour les types d'alarmes 2 à 4, des blocs dedonnées de paramètres qui contiendront des données supplémentaires de l'alarme correspondante.L'état de signal d'une alarme est placé dans un bloc de données d'offset. Les adresses des blocs dedonnées de paramètres sont rangées dans des blocs de données à numération continue, placésimmédiatement derrière le bloc de données d'offset correspondant.Relation entre bloc de données d'offset et bloc de données de paramètres:

Figure 3

09.99 Annexe


Type Nombre maxi Taille du bloc deparamètres

Nombre de blocs parDB de paramètres

Nombre maxi deDB de paramètres

1 1008 / 2016 - - -

2 1008 2 DW 128 8

3 1008 5 DW 51 20

4 1008 7 DW 36 28

Tableau 8Calcul du nombre des blocs de données de paramètres:

Veillez, lors de la configuration, à ce qu'il n'y ait pas de chevauchement d'adresse avec celles desblocs de données d'un autre type d'alarme et prévoir le nombre des blocs de données de paramètrespour les extensions futures possibles.Un bloc de données de paramètres contient des blocs de paramètres qui sont affectés aux différentesalarmes. Les blocs de paramètres sont rangés avec des numéros de série dans le bloc de données deparamètres en commençant par le bloc de paramètres correspondant à la première alarme de ce typed'alarme. Les blocs de paramètres continuent d'être numérotés au-delà des limites du DB deparamètres. Lorsque la fin d'un DB de paramètres est atteinte, la numérotation du bloc de paramètresest poursuivie avec le numéro suivant à partir du DW 0 du DB de paramètres suivant. Le système nerange que des blocs de paramètres entiers dans le bloc de données de paramètres.Calcul de l'adresse de début d'un bloc de paramètres:


Db paramètres = DB d'offset + 1 + (numéro d'alarme d'offset / blocs de paramètres parDB de paramètres)

Adresse de début de DB deparamètres

= (Numéro d'alarme d'offset % Blocs de paramètres par DB deparamètres) * Taille de bloc de paramètres

L'utilisateur doit veiller à ce que les données correspondantes (variables de process, numéro decontrat, étiquette de charge) se trouvent bien à la bonne adresse.

5.2.3.11 Structure d’un bloc d’alarmes

Un bloc d'alarmes envoyé au système de supervision WinCC est constitué de plusieurs mots dedonnées qui se suivent. Ces mots de données contiennent toutes les informations spécifiques auxalarmes. L'ensemble des mots de données forme un bloc d'alarmes. La taille des blocs de donnéesdiffère d'un type d'alarme à l'autre.Un bloc d'alarmes est toujours constitué, quel que soit le type d'alarme, d'au moins deux mots dedonnées: le numéro d'alarme et l'état d'alarme. Selon que les alarmes sont horodatées (3 mots dedonnées) et contiennent des paramètres ou non, un bloc d'alarmes peut atteindre la taille maximale de12 mots de données.

DW Description

1er DW Numéro d'alarme

2ème DW Etat d'alarme

3ème DW Heure

4ème DW Heure

Annexe 09.99


DW Description

5ème DW Date

6ème DW Variable de process

7ème DW Variable de process

8ème DW Numéro de contrat

9ème DW Numéro de contrat

10ème DW Etiquette de charge

11ème DW Réserve

12ème DW Réserve

Tableau 9

Lorsque les alarmes ne reçoivent pas d'horodatage, les trois mots de données correspondants sontsupprimés aux positions 3 à 5 du bloc. Les mots de données de paramètres suivent alorsimmédiatement le mot de données d'état. La taille d'un bloc d'alarmes (nombre de DW) varie avec letype d'alarme et l'horodatage, souhaité ou non; cette taille est indiquée dans le tableau 10.Détermination de la longueur des blocs d'alarmes en fonction du type d'alarme:

Type Longueur de bloc d’alarmes en DWsans horodatage

Longueur de bloc d’alarmes en DWavec horodatage

1 2 5

2 4 7

3 7 10

4 9 12

Tableau 10

5.2.3.12 Numéro d'alarme

Un numéro d'alarme permettant l'identification des alarmes est affecté à chaque alarme.

5.2.3.13 Etat d’alarme

L'état d'alarme se présente comme suit:

Tableau 11

5.2.3.14 Horodatage (Time Stamp)

La date et l'heure sont fournies en digital par le bloc fonctionnel FB 86 : MELD:UHR.

09.99 Annexe


5.2.3.15 Variable de process

Deux mots de données servant à stocker les variables de process lorsque survient une alarme et à lestransmettre au système process.

5.2.3.16 Numéro de contrat / Etiquette de charge

Les deux premiers mots de données doivent s'interpréter soit comme nombre dual 32 bits signé oucomme le total de quatre caractères ASCII selon la configuration qui a été effectuée. Le troisième motde données s'interprète comme deux caractères ASCII.Ces trois mots de donnés servent à transmettre à WinCC le numéro de contrat courant ou ladésignation de la charge lorsque survient une alarme.

5.2.3.17 Réserve

Les deux mots de données de réserve du type d'alarme 4 sont prévus pour les éventuelles extensions,mais ne sont pas occupés actuellement dans le système WinCC.

5.2.3.18 Génération d'un bloc d'alarmes

Lorsqu'une alarme a été détectée, le numéro d'alarme correspondant est déterminé à l'aide de laposition de bit constatée et rangée comme premier mot de données du bloc d'alarmes dans le tamponcyclique. Selon qu'il s'agit d'une alarme partie ou arrivée, horodatée ou non, et en fonction du typed'alarme, le masque d'états correspondant est sélectionné et rangé comme deuxième mot de donnéesdu bloc d'alarmes dans le tampon cyclique. Si le bit correspondant a été paramétré dans le bloc dedonnées système pour un horodatage, les mots de données suivants sont les trois mots de donnéesrangés au format PC et qui sont requis dans le bloc de données système 80 à partir de l'adresse DW190. Selon le type d'alarme dont il s'agit, le bloc de paramètres correspondant est éventuellement ludans l'archive de données (bloc de données de paramètres) et ajouté comme dernières informations aubloc de données contenu dans le tampon cyclique.Le bit d'état suivant de l'alarme suivante est testé. Ceci est répété jusqu'à ce que toutes les alarmesparamétrées ont été traitées.

5.2.3.19 Le tampon cyclique interne (FIFO)

Un tampon cyclique est une mémoire dont le traitement recommence à partir du haut lorsqu'il s'achèveen bas, c'est-à-dire, pour emprunter une image, que le traitement du contenu de la mémoire se faitavec un flux en forme d'anneau. Ceci permet, d'une part, de limiter la taille de la mémoire, et, d'autrepart, de disposer d'une mémoire infinie.Ceci a pour conséquence dans le système d'acquisition des données que, lorsque la fin virtuelle estatteinte sans qu'il y ait eu sortie des données anciennes du tampon (le tampon est plein), les donnéesles plus anciennes sont écrasées par les plus récentes et sont donc perdues.Le tampon cyclique en RAM sert, comme le nom l'indique, de tampon recevant les alarmes acquisesavant qu'elles ne soient transmises au PC. Dans la mémoire RAM, le tampon cyclique est constituéd'un espace mémoire d'une taille correspondant au minimum à deux blocs de données et peut, selon leparamétrage, être configuré librement dans les limites du nombre maximal de blocs de données permispour un automate programmable ou des DB encore disponibles dans le programme utilisateur.L'utilisateur communique au système d'alarmes un nombre de blocs de données disponible pourl'archivage.Lorsqu'il y a plusieurs blocs de données, il est indispensable d'utiliser des blocs de données numérotésen continu. Ainsi l'utilisateur peut entrer dans le DB système comme paramètres le numéro de DB dedébut et le numéro de DB de fin du tampon. Tous les blocs de données dont les numéros sont situésentre ceux du DB de début et du DB de fin (les deux blocs de données limite inclus) forment lamémoire tampon.

Annexe 09.99


5.2.3.20 Le bloc interface - pour transmission des données au système WinCC

Le système d'alarmes S5 écrit d'une manière générale dans le tampon cyclique interne toutes lesalarmes du cycle exécuté.Les enregistrements d'alarme (pouvant contenir jusqu'à un bloc de données) sont transmis vial'interface si celle-ci est prête à les recevoir. L'interface d'alarme, qui est un bloc de données, sert desource de données au bloc de fonctions de transfert (bloc de transfert STEP 5). Les blocs de transfertforment une interface vers le processeur de communication correspondant pour le bus process utilisé(par exemple pour le bus SINEC-H1).

Structure du bloc interface:

DW Contenu

DW 0 Longueur du bloc de données

DW 1 KY = [ No API ] , [ No CPU ]

DW 2 KY = [ 0 ] , [ Nombre des alarmes ]

DW 3 Début des données utiles (blocs d'alarmes)

Tableau 12

DW 0:

Tableau 13

Le DW 0 du bloc interface est indiqué par le bit numéro 14 Front de déclenchement d'un contratsouhaité, et deuxièmement des bits 0-8 longueur données source.Le bloc de données transmis ne devant pas dépasser 256 mots de données et un octet ne permettant dereprésenter qu'un nombre inférieur ou égal à 255, le test séparé des octets par les commandes DL ouDR n'est pas possible. C'est pourquoi nous recommandons de transférer le DW 0 dans un mémentoauxilliaire. Ceci présente également l'avantage que le bit d'autorisation peut être testé directement.Cette opération n'est pas applicable à l'utilisation de mots de données.

Lorsque la condition est remplie, le bit servant de front pour un déclenchement de contrat de transfertdoit être remis à 0. Les bits à 1 restants correspondent alors à la longueur des données sourcetransmises et peuvent être écrits dans la zone de données du paramétrage indirect comme QLAE.Après l'exécution réussie d'un contrat WRITE (SINEC-H1) envoyé au système WinCC ("terminé sanserreur" (FOF)) le DW 0 du bloc interface doit être écrasé avec la valeur 0. Le bloc interface est alors ànouveau disponible pour recevoir d'autres blocs d'alarmes du tampon cyclique interne.Le contrat WRITE (SINEC-H1) doit être réalisé avec la fonction SEND Direct. Se reporter au manuelcorrespondant de l'automate programmable.

09.99 Annexe


5.2.4 Description d’interface

Les interfaces suivantes doivent être décrites:

• Bloc de données système DB 80:pour paramétrage du système d'alarmes S5.

• Bloc de données d'offset pour le type d'alarme correspondant:interface binaire des signauxd'alarme pour le système d'alarmes S5 avec spécifications des propriétés d'alarme.

• Bloc de données de paramètres pour le type d'alarme correspondant:pour configuration de donnéesd'alarmes supplémentaires pour alarmes des types 2 à 4.

• Bloc interfaceinterface de transfert vers WinCC.

5.2.4.1 Bloc de données système 80

Le bloc de donnés système DB 80 sert à configurer des zones de données indépendantes les unes desautres pour quatre types d'alarmes, un tampon cyclique et un bloc interface. Les mots de données 0 à20 du DB 80 sont prévus pour cette configuration.

5.2.4.2 Bloc de données d'offset

Le système d'alarmes S5 exploite les états de signal des alarmes correspondantes et génère, à partir deceux-ci, les blocs d'alarmes.L'utilisateur doit veiller à ...

• indiquer à la configuration les états de repos des alarmes.

• ce que les états des alarmes soient écrits dans les bits d'état de signal correspondants durantl'exécution du programme utilisateur S5.

• ce que les bits d'acquittement correspondants soient lus et exploités en cas de besoin.

5.2.4.3 Bloc de données de paramètres

Pour les types d'alarmes 2 à 4, des informations supplémentaires sur l'état courant du process peuventêtre transmises par le bloc d'alarmes.L'utilisateur doit veiller à ...

• ce que, à l'arrivée d'une alarme, les variables de process valides (valeur de process, numéro decontrat et numéro de charge) figurent dans les blocs de paramètres correspondants.

5.2.4.4 Bloc interface

Dès qu'il contient des blocs d'alarmes, le bloc interface est transmis au système WinCC par un contratWRITE (SINEC H1).L'utilisateur doit veiller à ...

• ce que les blocs de transfert correspondants de la CPU soient présents.

• indiquer, lors de la configuration du système WinCC, les canaux de communication pour uneconnexion au bus de process.

• ce qu'un contrat WRITE soit déclenché.

Annexe 09.99


5.2.5 Paramétrage du système d'alarmes S5 / DB Système 80

Description des mots de données configurables dubloc de données système DB 80:

DW Description

0 Adresse DB: Début FIFO interne

1 Adresse DB: Fin FIFO interne

2 0: sans date ni heure 1: avec date et heure

3 DB d'offset pour alarmes du type 1

4 1: 1 DB d'offset du type 1 2: 2 DB d'offset du type 1




8 Réserve

9 Réserve

10 Adresse DB: bloc de données interface CPU -> PC

11 1: acquisition optimisée (EFOP)

12 EFOP à partir de n alarmes

13 Type d'automate (115 / 135 / 155)

14 Réserve (doit être 1)

15 No automate: 1..255; No CPU: 1..4

16 Réserve

17 Réserve

18 Réserve

19 Réserve

20 PAFE du contrôle de vraisemblance

Tableau 14DW 0, DW 1: DB de zone mémoire du tampon cyclique interneLes deux mots de données définissent la zone mémoire occupée par le tampon cyclique interne desalarmes.L'espace mémoire doit être au minimum égal à deux blocs de données. Veillez en outre à ce quel'adresse de fin de tampon FIFO soit supérieure à celle du début du tampon.L'espace mémoire du tampon est défini par la zone de blocs de données délimitée par le début et la findu tampon FIFO, les deux blocs de données de définition inclus.Sélection de la taille du tampon cyclique:Lorsque l'espace mémoire du tampon cyclique est plein, les alarmes les plus anciennes sont écrasées.Choisissez un nombre de DB suffisamment grand pour qu'aucune alarme ne soit écrasée avant letransfert en cas d'avalanche d'alarmes. La règle ci-dessous permet un dimensionnement de la mémoirepermettant d'éviter cet écrasement intempestif.Calcul du nombre de DB du tampon cyclique:Alarmes par DB = (255 DW / DB) / Longueur de bloc d'alarmesVoir tableau 10

Il est conseillé de prévoir un ou deux blocs de plus pour l’acquisition optimisée des alarmes.DW 2 : Code date et heure

09.99 Annexe


Le choix d'horodater les alarmes est fait pour toutes les alarmes paramétrées. Soit que toutes lesalarmes à acquérir reçoivent un horodatage (DW2 = 1), soit qu'elles restent toutes sans horodatage(DW2 = 0). Lorsque vous mettez DW2 = 0, le système WinCC ajoute un horodatage aux blocd'alarmes arrivés.DW 3, DW 4 : DB d'offset du type d'alarme 1Pour configurer des alarmes du type 1 (alarmes sans paramètres et étiquettes de charge), vous devezindiquer l'adresse du bloc de données d'offset dans le mot de données 3. Les états de signal de cesalarmes doivent être écrits en continu par le programme de l'automate dans ces blocs de données.Lorsque plus de 1008 alarmes (2016 alarmes au maximum) du type 1 sont configurées, vous devezentrer le chiffre 2 dans le mot de données 4 pour libérer un autre bloc de données pour alarmes du type1. Ce deuxième bloc de données a l'adresse immédiatement supérieure par rapport à l'adresse contenuedans le DW 3. Lorsque le nombre maximal des alarmes du type 1 est 1008, vous entrez le chiffre 1dans le mot DW 4.DW 5, DW 6, DW 7 : DB d'offset des types d'alarmes 2, 3, 4Comme pour le DW 3, les mots de données 5-7 contiennent les adresses des blocs de données danslesquels les signaux des alarmes sont rangés.Le DW 5 contient l'adresse du bloc de données du type d'alarme 2; le DW 6 l'adresse du bloc dedonnées du type d'alarme 3 et le DW 7 l'adresse du bloc de données du type d'alarme 4.Un 0 doit être entré dans le mot de données DW correspondant lorsqu'un type d'alarme n'est pasutilisé.Il s'agit pour les adresses indiquées dans les DW 5-7 de DB d'offset. Un certain nombre de DB ajoutésderrière ceux-ci et correspondant au type d'alarme et au nombre d'alarmes par type est affecté à cesDB d'offset. Ces DB ajoutés contiennent les paramètres des alarmes. C'est pourquoi il faut veiller, lorsde l'attribution des adresses de DB d'offset, à prévoir suffisamment de place (en blocs de données)pour ces DB de paramètres entre les DB d'offset et le bloc à configurer.On peut configurer au maximum 1008 alarmes pour chaque type d'alarme 2-4. Si on utilise lespossibilités maximales, il en résulte pour des types d'alarmes différents un nombre différents de DB deparamètres placés derrière les DB d'offset (voir tableau 8).DW 10 : Interface d'alarme vers le système WinCCLe mot de données 10 doit toujours être paramétré quel que soit le mode de fonctionnement utilisépour le système d'acquisition des alarmes. Le DW 10 sert à attribuer l'adresse DB du bloc interface.Ce bloc sert d'interface entre le système SIMATIC S5 et WinCC.DW 11 , DW 12 : Sélection du mode d'acquisition optimisée et du nombre d'alarmes correspondantDeux modes de fonctionnement sont possibles:

• '0' dans DW 11 -> ’Mode normal’ du système d'acquisition d'alarmes

• '1' dans DW 11 -> 'Mode Acquisition optimisée'

Mode normal:

Il est transféré au cours d'un cycle autant d'alarmes acquises depuis le tampon interne que l'interfacepeut en contenir, à condition que celle-ci soit prête à recevoir des données.Lorsque le nombre d'alarmes acquises est très élevé pendant un cycle ou pendant plusieurs cyclessuccessifs, cette procédure entraînerait un temps de cycle relativement élevé. Ce temps de cycle estd'autant plus long que les blocs d'alarmes des types d'alarmes concernés sont volumineux. Dans cecas, l'acquisition des blocs de données est plus lourde et dure plus longtemps.

Annexe 09.99


Acquisition optimisée:

L'acquisition chronologique des alarmes est prioritaire sur leur émission au PC. Ce qui importe, c'estle temps relatif entre les alarmes du process qui apparaissent. Le fait que les alarmes parviennent auPC avec quelques millisecondes de retard est secondaire. L'inertie de l'oeil humain et la capacité deperception de l'observateur en salle de contrôle sont par contre décisives.C'est pour réduire le temps de cycle du système d'acquisition des alarmes dans ce genre de situationcritique que le mode de fonctionnement "Acquisition optimisée" a été introduit. Vous devez entrer lenombre minimum d'alarmes par cyle OB1 dans le mot DW 12. Lorsque le nombre des alarmesdépasse ce nombre minimum pendant l'exécution du cycle courant OB1, les alarmes sont uniquementacquises et enregistrées en tampon. Il est renoncé dans ce cycle OB1 au transfert et à l'envoi à uncorrespondant.DW 15 : No API / No CPUCe mot de données est nécessaire à la formation de l'en-tête de télégramme. Vous devez paramétrer lenuméro de l'API dans le projet et le numéro de la CPU de cet automate programmable. Le numéro dela CPU est notamment important lorsque plusieurs CPU sont exploitées sur un même automate. Cen'est qu'à l'aide de ce mot de données, qui contient le code des alarmes, que le système WinCC peutinterpréter comme une alarme les données envoyées, affecter les textes d'alarme spécifiques à cesalarmes et les exploiter.Lors du paramétrage, le mot DW 15 est le seul mot de données ayant le format S5 'KY'. Celui-cipermet de séparer deux octets (par une virgule). L'octet de gauche contient le numéro de l'automate,qui peut être compris entre 1 et 255. L'octet de droite contient le numéro de la CPU qui peut êtrecompris entre 1 et 4.

Exemple:

KY = 10,2

No API = 10

No CPU = 2

DW 20 : Erreur de paramétrageLa cohérence de tous les mots de données paramétrés dans le DB sytème est vérifiée au démarrage dusystème d'alarmes S5. Ce contrôle distingue les dépassements de plages de valeurs, leschevauchements ou affectations multiples de blocs des données paramétrés ainsi que les donnéesmanquantes.Ce bloc fonctionnel possède comme paramètre de sortie au format d'un mot de données un mot PAFE(mot d'erreur de paramétrage). La fonction est similaire à celle des blocs de transfert spécifiques ausystème. L'état du mot PAFE peut être lu dans le mot DW 20 du DB système 80. Après retour auprogramme en fin d'exécution de FB 81, le mot PAFE est analysé pour l'identification des erreurs. Lesmesures correctrices peuvent alors être prises.Lorsque le mot PAFE d'un automate programmable est différent de 0, il est judicieux de faire "sauter"l'automate sur l'état Stop. Si le mot PAFE n'est pas analysé, il ne peut être garanti que le programmefonctionne correctement.Exploitation du mot PAFESi le programme ou l'API a été mis sur l'état Stop, comme nous l'avons recommandé, à l'apparitiond'une erreur (mot PAFE 0, l'erreur peut être analysée et éliminée à l'aide du numéro d'erreur. Letableau suivant renseigne sur le type d'erreur causée par le paramétrage.

Format du mot PAFE:

KY = Numéro d'erreur, code d'erreurs groupées

09.99 Annexe


Exemple:

KY = 9,1

Erreur de paramétrage avec numéro 9 signifie:Adresse DB d'offset du type d'alarme 1 supérieure à l'adresse de DB maxi.

No erreur Signification

1 DB de début de tampon interne pas défini

2 DB de début de tampon interne identique à l'adresse du DB système ('80')

3 Adresse de DB de début de tampon interne supérieure à l'adresse de DBmaxi autorisée

4 DB de fin de tampon interne identique à l'adresse du DB système ('80')

5 Adresse de DB fin inférieure à l'adresse de DB de début du tampon interne

6 Adresse de DB de fin de tampon interne supérieure à l'adresse de DB maxiautorisée

7 DB d'offset type d'alarme 1 même adresse que DB système ('80')

8 Adresse DB d'offset type d'alarme 1 dans la zone mémoire du tamponinterne

9 Adresse DB d'offset type d'alarme 1 supérieure à l'adresse DB maxiautorisée


11 DB d'offset type d'alarme 2 même adresse que DB d'offset type 1

12 DB d'offset type d'alarme 2 même adresse que le deuxième DB d'offset typed'alarme 1
















28 Bloc interface PC même adresse que DB système ('80')

Annexe 09.99


No erreur Signification

29 Bloc interface PC pas défini ('0')

30 Adresse bloc interface PC dans zone mémoire du tampon interne

31 Adresse bloc interface PC supérieure à adresse DB maxi autorisée

32 Adresse bloc interface PC identique à adresse DB d'offset type d'alarme 1




36 Bloc interface PC même adresse que deuxième DB d'offset type d'alarme 1

37 Réserve DW 9 ou réserve DW 10 différent 0










47 Le nombre d'alarmes pour le seuil mini du mode Acquisition optimiséemanque

48 Type d'automate pas défini

49 Réserve DW 14 différent de 1

50 Numéro API pour en-tête télégramme pas défini

51 Numéro CPU pour en-tête télégramme pas défini

52 Numéro CPU supérieur au numéro maxi autorisé (1..4)

Tableau 15

09.99 Annexe


5.2.6 Exemple de configuration pour le systme d’alarmes S5

Description

Le système d'alarmes S5 doit être configuré pour les types d'alarmes suivants:

Type Définition: types d'alarmes

1 1200 alarmes (du numéro 10000 au numéro 11199) Alarmes 11000 à 11199 "actives à l'état low"

2 Aucune alarme prévue

3 11 alarmes (du numéro 30000 au numéro 30010)

4 Aucune alarme prévue

Toutes les alarmes reçoivent un horodatage.Matériel utilisé: API 135U, No API 1, No CPU 1.

5.2.6.1 Paramétrage du DB 80

Type Nombre maxi Taille du bloc deparamètres

Nombre de blocs parDB de paramètres

Nombre maxide DB deparamètres

1 1008 / 2016 - - -

2 1008 2 DW 128 8

3 1008 5 DW 51 20

4 1008 7 DW 36 28

Le DB 81 est utilisé comme interface vers le PC.Si l'on admet une apparition régulière des alarmes existantes, la longueur moyenne d'un bloc d'alarmesest de (avec date/heure):(1200 * 5 + 11 * 10) / (1200 + 11) = 5,04Données du problème:Le système d'alarmes S5 doit pouvoir supporter une avalanche de 100 alarmes dans un cycle d'API etfonctionner en mode "Acquisition optimisée" à partir de 30 alarmes.

5 DW/Alarme * 100 Alarmes = 500 DW

(500 DW) / (256 DW/DB) = 1,95 DB

Cela donne pour la taille du tampon cyclique quatre blocs de données, étant donné que l'on doitcompter un à deux blocs de données de plus pour le mode Acquisition optimisée.Le tampon cyclique commence à l'adresse de bloc de données 82 et se termine donc à l'adresse DB 85.Afin de prévoir une réserve d'espace mémoire pour une éventuelle extension future du tamponcyclique, le bloc de données d'offset se trouve pour le type d'alarme 1 sur les DB 88 et DB 89 (plus de1008 du type 1).Le DB 90 devient le bloc de données d'offset du type d'alarme 3. Un DB de paramètres du typed'alarme 3 a un espace mémoire de 51 blocs de paramètres; si on en soustrait les 11 blocs utilisés, on aavec un seul bloc de paramètres (DB 91) une possibilité d'extension de 40 alarmes du type 3.

Annexe 09.99


DW Description Valeur

0 Adresse DB: début FIFO interne 82

1 Adresse DB: fin FIFO interne 85

2 0: sans date et heure

1: avec date et heure

1

3 DB d'offset pour alarmes du type 1 88

4 1: un DB d'offset alarme type 1

2: deux DB d'offset alarme type 1

2




8 Réserve 0

9 Réserve 0

10 Adresse DB: interface CPU -> PC 81

11 1: acquisition optimisée (EFOP) 1

12 EFOP à partir de n alarmes 30

13 Type automate (115 / 135 / 155) 135

14 Réserve 1

15 No automate: 1..255; No CPU: 1..4 1, 1

16 Réserve 0

17 Réserve 0

18 Réserve 0

19 Réserve 0

20 PAFE du contrôle de vraisemblance 0

Les DW 10 à DW 20 du bloc de données 100 sont utilisés pour la synchronisation de l'heure.Les DW 0 à 255 du bloc de données 101 servent à stocker les commandes.

5.2.6.2 Paramétrage des blocs de données

Création des blocs de données DB 81 - DB 85, DB 88 - DB 91 et DB 101 de DW 0 - DW 255.Création du bloc de données DB 100 de DW 0 - DW 20.

5.2.6.3 Initialisation des blocs de données d'offset

Type d’alarme 1Les DB prévus pour le type d'alarme 1 sont les DB 88 et DB 89. DB 88 contient les alarmesnumérotées 10000 à 11007, DB 89 les alarmes numérotées 11008 à 11199.Au total, 1200 alarmes du type 1 doivent être configurées.Voir chapitre Adresse du dernier bloc d'états de signalNuméro d'alarme d'offset = Numéro d'alarme - Numéro de base = 0 à 1199

1er DB d’offset:

Adresse du dernier bloc d'états de signal: DW 252

09.99 Annexe


2ème DB d'offset:

Adresse du dernier bloc d'états de signal: DW 252

1200 - 1008 = 192

192 / 16 = 12

192 % 16 = 0

Adresse du dernier bloc d'états de signal dans le 2ème bloc de donnéesd'offset

= 12 * 4 = 48

DB 88:


DW 0 Non affecté

DW 1 Numéro d'alarme de base 10000

DW 2 Adresse du dernier DW: 252

DW 3 Non affecté

DB 89:


DW 0 Non affecté



DW 3 Non affecté

Voir chapitre Numéro d'alarme d'offset / Etats de signal des alarmesLes alarmes 11000 à 11199 sont "low active".Position du bit de repos de l'alarme 11000:

Numéro d'alarme d'offset: 11000 - 10000 = 1000

Début du bloc d'états de signal (Numéro d'alarme d'offset / 16 + 1) * 4 == (62 + 1) * 4 * DW 252

Mot de données des bits de repos: DW 253

Bit de données: Numéro d'alarme d'offset % 16 = 8

Bloc de données: Bloc de données d'offset = DB 88

Position du bit de repos de l’alarme 11000:

Numéro d'alarme d'offset: 11199 - 10000 = 1199

Début du bloc d'états de signal: (Numéro d'alarme d'offset / 16+ 1) * 4 = (74 +1) * 4 = 300300 - 252 = 48

Mot de données des bits de repos: DW 49

Bit de données: Numéro d'alarme d'offset % 16 = 15

Bloc de données: Bloc de données d'offset + 1 = DB 89

Les bits d'états de repos suivants sont à modifier:

Annexe 09.99


DB 88:

DW 253: bits de données 8 à 15 doivent être mis à 1

DB 89:

DW 5, DW 9, DW 13, ... DW 49 : bits de données 0 à 15 doivent être mis à 1Type d'alarme 3Pour le type d'alarme 3, c'est le DB 90 qui est prévu comme bloc de données d'offset avec les alarmes30000 à 30010 et le DB 91 comme bloc de données de paramètres.Au total, 11 alarmes du type 3 doivent être configurées.Voir chapitre Structure des blocs de données de paramètresNo d'alarme d'offset = No d'alarme - No de base = 0 à 10

Db d’offset:

Adresse du dernier bloc d'états de signal: 11 / 16 = 0 11 % 16 = 11

Adresse du dernier bloc d'états de signal = (0+1) * 4 = 4

DB 89:


DW 0 Non affecté



DW 3 Non affecté

Tous les bits d'états de repos sont 0.Voir chapitre Structure des blocs de données de paramètres

DB de paramètres = DB d'offset + 1 + (Numéro d'alarme d'offset / Blocs de paramètres par DB deparamètres)

Numéro d'alarme 30000:DB de paramètres = 90 + 1 + 0 / 51 = 91Numéro d'alarme 30010:DB de paramètres = 90 + 1 + 10 / 51 = 91

Adresse de début du bloc de paramètres = (Numéro d'alarme d'offset % Blocs de paramètres parDB de paramètres) * Taille du bloc de paramètres

Numéro d'alarme 30000:

Adresse de début du bloc de paramètres = (0 % 51) * 5 = DW

Numéro d'alarme 30010:

Adresse de début du bloc de paramètres = (10 % 51) * 5 = DW 50

DB 91: bloc de données de paramètres 91 pour le bloc de données d'offset 90

09.99 Annexe


No d’alarme Valeurs de process No de contrat Etiquette de charge

30000 DW 0, 1 DW 2, 3 DW 4

30001 DW 5, 6 DW 7, 8 DW 9

30002 DW 10, 11 DW 12, 13 DW 14

30003 DW 15, 16 DW 17, 18 DW 19

30004 DW 20, 21 DW 22, 23 DW 24

30005 DW 25, 26 DW 27, 28 DW 29

30006 DW 30, 31 DW 32, 33 DW 34

30007 DW 35, 36 DW 37, 38 DW 39

30008 DW 40, 41 DW 42, 43 DW 44

30009 DW 45, 46 DW 47, 48 DW 49

30010 DW 50, 51 DW 52, 53 DW 54

Annexe 09.99


5.2.7 Documentation des blocs de commandes SIMATIC S5

Fonction des blocs de commande SIMATIC S5

Le logiciel sert à "traiter" les bits, octets, mots et double-mots dans l'environnement SIMATIC S5 viaun bus de process (p. ex. SINEC H1). Vous ne pouvez accéder par le bus de process qu'aux octets etaux valeurs de mot de l'automate SIMATIC S5.Les opérations suivantes peuvent être exécutées en standard:

• Les mots de donnés DB et DX, Timer et Counter ne peuvent être modifiés que par mots entiers.

• Les mémentos, les entrées et sorties, la périphérie (P et Q) ne peuvent être modifiés que par octets.Le logiciel fournit dans l'environnement SIMATIC S5 les fonctionnalités logicielles nécessaires àl'exécution des opérations suivantes depuis WinCC via le bus de process:

• Activer une impulsion de sens pour la durée d'un cycle OB1

• Activer / désactiver / inverser bit dans DB / DX

• Activer / désactiver / inverser bit dans mémento

• Ecrire octet de gauche / de droite dans DB / DX

• Ecrire mot / double-mot dans DB / DX

• Ecrite octet / mot dans mémento

• Ecrire octet / mot dans périphérie

• Ecrire octet / mot dans périphérie étendueLes modifications à réaliser dans l'automate SIMATIC S5 sont mises à disposition par WinCC -Control Center sous forme de variable de donnés brutes via une interface de données. Les commandesdoivent être envoyées à l'automate S5 par la variable de données brutes. Ces commandes sontinterprétées directement dans l'automate S5 par un interpréteur de commandes FB 87 : EXECUTE etexécutées.Le présent manuel décrit de manière détaillée l'utilisation des blocs de commandes S5 dansl'environnement SIMATIC S5. Il fournit à l'utilisateur un panorama des blocs de données et blocsfonctionnels utilisés par le logiciel et indique l'espace mémoire nécessaire. Vient ensuite unedescription détaillée de l'interface de données existante. Un exemple de configuration complète laprésentation.

5.2.7.1 Liste des blocs logiciels

Les blocs de commandes S5 de SIMATIC S5 sont rangés dans le fichier WINCC1ST.S5D sur le CD-ROM WinCC.Ce fichier contient les blocs fonctionnels suivants pour blocs de commandes S5:

FB Nom Taille en octets Fonction

FB 87 EXECUTE 152 Permet les manipulations sur bits, octets, motset double-mots via le bus de process

FB 88 OPCODE 399 Bloc appelé par FB 87

Total 551

Tableau 16Il faut en plus un bloc de données de commandes de 512 octets.

09.99 Annexe


5.2.7.2 Matériel requis

Les blocs fonctionnels du tableau 16 supposent, pour être correctement exécutés, l'utilisation dumatériel suivant:

API CPU

AG 115U CPU 943, CPU 944, CPU 945

AG 135U CPU 928A, CPU 928B

AG 155U CPU 946/ 947, CPU 948

5.2.7.3 Paramètres d'appel de FB 87: EXECUTE

Nous décrivons ci-dessous les paramètres d'appel du bloc fonctionnel FB 87 : EXECUTE.

Nom EXECUTE Paramètres

Dés: DBNR E/A/D/B/T/Z: D KM/KH/KY/KC/KF/KT/KZ/KG: KF

Dés: DBDX E/A/D/B/T/Z: D KM/KH/KY/KC/KF/KT/KZ/KG: KF

Dés: RIMP E/A/D/B/T/Z: D KM/KH/KY/KC/KF/KT/KZ/KG: KY

DBNR: numéro bloc de données de l'interface de commandesDBDX: type de source de données pour l'interface de commandesDB: la source de données est un bloc de données (DB).DX: la source de données est un bloc de données étendu (DX).RIMP: position binaire pour l'impulsion de sensRIMP: numéro de mémento, numéro de bit

Annexe 09.99



Nous décrivons ci-après les interfaces et les blocs de donnés ci-dessous:

• Bloc fonctionnels de commandes FB 87

• Bloc de données de commandes: interface de transfert de commandes vers SIMATIC S5.Dans l'automate SIMATIC S5, l'interpréteur de commandes (FB 87 : EXECUTE) est appelécycliquement dans OB 1. Le type et l'adresse du DB de commandes sont passés comme paramètres.Lorsqu'une commande est présente, le code OP et quatre paramètres sont passés au FB 88 : OPCODEet exécutés directement. Une fois la commande exécutée, le compteur de commandes (DW 1) estincrémenté de 1. La procédure de passage de commande et de décrémentation du compteur decommandes est répétée jusqu'à ce que toutes les commandes présentes ont été exécutées.Les paramétrages du type et de l'adresse du bloc de données doivent être identiques dans WinCC -Control Center et dans le programme S5 et le bloc de données doit être présent dans l'automate S5.L'utilisateur peut choisir entre un bloc de données DB et un bloc de données DX et son adresse (p. exDX 234). Vous devez ouvrir le bloc de données jusqu'au mot 255, les mots 0-255 pouvant êtreadressés dans le bloc de données paramétré.La syntaxe des commandes rangées dans le bloc de données de commandes est la suivante:

DW Description

0 Pas utilisé

1 Nombre des commandes à exécuter

2 Code OP de la première commande

3 Paramètre 1 (Opcode 1)




7 Code OP de la deuxième commande






13 Code OP de la troisième commande


......

Ci-dessous la syntaxe des commandes implémentées:

Passage du code OP et des paramètres dans DB de commandes

Commande Code OP Paramètre 1 Paramètre 2 Paramètre 3 Paramètre 4

Activer bit dansDB

10 DB DW Bit -

Désactiver bitdans DB

11 DB DW Bit -

Inverser bit dansDB

12 DB DW Bit -

Activer octetdroit dans DB

15 DB DW Valeur -

09.99 Annexe


Commande Code OP Paramètre 1 Paramètre 2 Paramètre 3 Paramètre 4

Activer octetgauche dans DB

16 DB DW Valeur -

Ecrire mot dedonnées dansDB

17 DB DW Valeur -

Ecrire double-mot dans DB

18 DB DW Valeur Valeur

Activer bit dansDX

20 DX DW Bit -

Désactiver bitdans DX

21 DX DW Bit -

Inverser bit dansDX

22 DX DW Bit -

Activer octetdroit dans DX

25 DX DW Valeur -

Activer octetgauche dans DX

26 DX DW Valeur -

Ecrire mot dedonnées dansDX

27 DX DW Valeur -

Ecrire double-mot dans DX

28 DX DW Valeur Valeur

Activer bit demémento

30 MB Bit - -

Désactiver bitde mémento

31 MB Bit - -

Inverser bit demémento

32 MB Bit - -

Ecrire octet demémento

35 MB Valeur - -

Ecrire mot demémento

36 MW Valeur -

Ecrire octet depériphérie

45 PB Valeur - -

Ecrire mot depériphérie

46 PW Valeur - -

Ecrire octet depériphérieétendu

55 QB Valeur - -

Ecrire mot depériphérieétendu

56 QW Valeur - -

Activerimpulsion desens

60 - - - -

Annexe 09.99


5.2.8.1 Exemple de configuration des blocs de commandes S5

L'exercice consiste à configurer les blocs de commandes S5.L'impulsion de sens est mise à disposition dans le mot de mémento 56, bit 4. Le bloc de données decommandes sera le bloc DX 237. Veillez à ce que le bloc DX 237, mots DW 0 à 255, soit ouvert.Dans WinCC Control-Center, saisissez le bloc de données souhaité lors de la saisie des paramètres decanal (p. ex. SINEC H1).

Extrait du bloc OB 1:

09.99 Annexe


5.2.9 Fonction de la synchronisation d’heure S5

La présente documentation décrit les fonctions et les propriétés du logiciel SIMATIC S5:

Synchronisation de l’heure S5

Ce logiciel réalise la synchronisation de l'horloge système SIMATIC S5. Elle fournit en outre unformat adapté de données de date / heure à l'"acquisition chronologique" des alarmes du systèmed'alarmes S5 pour la constitution des blocs d'alarmes.Le bloc fonctionnel FB 86 : MELD:UHR fournit en outre l'heure système S5 au format requis parl'"acquisition chronologique des alarmes". Les données sont disponibles dans le bloc de donnéessystème 80, à partir du mot DW 190.En présence d'un changement de l'état de signal d'une alarme, l'alarme correspondante est identifiée àl'aide du numéro d'alarme par le bloc fonctionnel FB 80 : SYSTEMFB et horodatée avec le timestamp courant fourni par le bloc de données système 80.Le présent manuel décrit de manière détaillée l'utilisation de la synchronisation de l'heure S5 dansl'environnement SIMATIC S5. Il fournit à l'utilisateur un panorama des blocs de données et blocsfonctionnels utilisés par le logiciel et indique l'espace mémoire nécessaire. Un exemple deconfiguration complète la présentation.

5.2.9.1 Liste des blocs logiciels

Le logiciel SIMATIC S5 (synchronisation de l'heure S5) est rangé sur le CD-ROM WinCC dans lefichier: WINCC1ST.S5D.

Le fichier contient les blocs de données et blocs fonctionnels ci-dessous:

FB Nom Taille en octets Fonction

FB 86 MELD:UHR 1135 Synchronisation de l’heure

Total 1135

Tableau 17

Zone de données d'heure dans 115U: 27 DW = 54 octets

Zone de données d'heure 135U/155U: 12 DW = 24 octets

Zone de données pour le systèmed'alarmes S5:

3 DW = 6 octets

5.2.9.2 Matériel requis

Les blocs fonctionnels du système d'alarmes S5 supposent, pour être correctementexécutés, l'utilisation du matériel suivant:

API CPU

AG 115U CPU 944 * , CPU 945

AG 135U CPU 928B

AG 155U CPU 946/ 947, CPU 948

* seule la CPU 944 à deux interfaces pour console de programmation possède une horloge système

Annexe 09.99


5.2.10 Paramètres d'appel de FB 86 : MELD:UHR

Nous décrivons ci-dessous les paramètres d'appel du bloc fonctionnel FB 86 : MELD:UHR.Nous décrivons ci-dessous les paramètres d'appel du bloc fonctionnel FB 87 : EXECUTE.

Nom MELD:UHR Paramètres

Dés: CPUT E/A/D/B/T/Z: D KM/KH/KY/KC/KF/KT/KZ/KG: KF

Dés: DCF7 E/A/D/B/T/Z: D KM/KH/KY/KC/KF/KT/KZ/KG: KF

Dés: QTYP E/A/D/B/T/Z: D KM/KH/KY/KC/KF/KT/KZ/KG: KF

Dés: QSYN E/A/D/B/T/Z: D KM/KH/KY/KC/KF/KT/KZ/KG: KY

Dés: UDAT E/A/D/B/T/Z: D KM/KH/KY/KC/KF/KT/KZ/KG: KY

Dés: ZINT E/A/D/B/T/Z: D KM/KH/KY/KC/KF/KT/KZ/KG: KF

Dés: ZUHR E/A/D/B/T/Z: D KM/KH/KY/KC/KF/KT/KZ/KG: KY

Dés: ZSYN E/A/D/B/T/Z: D KM/KH/KY/KC/KF/KT/KZ/KG: KF

CPUT

No CPU Type

1 CPU 943 / CPU 944

2 CPU 945

3 CPU 928B

4 CPU 946/ 947, CPU

5 CPU 948

DCF7:

Mode de fonctionnement0 = Fonctionnement avec horloge système S51 = Fonctionnement avec radio-horloge DCF77

QTYP:

type de la source de données pour le télégramme de synchronisation de l'heure.0 = la source de données est un bloc de données (DB).1 = la source de données est un bloc de données étendu (DX).

QSYN:

source des données d'heure

DCF7 = 0: QSYN = Numéro DB, numéro DW du télégramme de synchronisation de l'heure reçu

DCF7 = 1: QSYN = Numéro DB, numéro DW de l'heure DCF77

UDAT:

adresse de la zone de données de l'heureUDAT = Numéro DB, numéro DW

09.99 Annexe


ZINT:

intervalle en minutes d'émission du télégramme de synchronisation (DCF7 = 1)

ZUHR:

zone de données cible pour données d'heure au format du système d'alarmes.ZUHR = Numéro DB, numéro DW

ZSYN:

zone de données cible pour le télégramme de synchronisation de l'heure (DCF7 = 1)Un format de données d'heure spécial est attendu à partir du DW 190 dans le DB 80 si la fonctiond'"acquisition chronologique des alarmes" doit être utilisée avec le système d'alarmes S5.Ce format de données d'heure est dérivé de l'heure système S5 et écrit dans la zone de données ZUHR(DB 80, DW 190-192).Relation entre la fonction "Acquisition chronologique des alarmes" et FB 86: MELD:UHR :

Figure 4

Annexe 09.99


5.2.11 Formats de données pour la date et l'heure

Télégramme de synchronisation de l'heure depuis un système (WinCC ne supporte pas pour lemoment le télégramme d'heure!!)Le premier mot de données du télégramme de synchronisation de l'heure contient un code de sourcequi est envoyé avec les données de date et d'heure par le système.Le bloc fonctionnel FB 86 : MELD:UHR ne prend en compte le télégramme présent qu'à partir dumoment où le code source FFFF est présent à cet endroit. La réception du télégramme est acquittéepar un 0 dans ce mot de données. Il n'est lu et exploité qu'à la réception d'un nouveau télégramme DW1 = FFFF).

Signification Mot de données Contenu Plage de valeur Remarque

Code source /Télégrammed'heure

1 FFFF

Identificateur dutélégramme

2 FFFF Pas utilisé

Secondes 3 00xx xx: 0..59

Minutes 4 00xx xx: 0..59

Heures 5 00xx xx: 0..23

Jour 6 00xx xx: 1..31

Mois 7 00xx xx: 1..12

Année 8 00xx xx: 0..127(1990-2117)

Année + 1990

Jour de lasemaine

9 00xx xx: 0..6 Dimanche = 0

Jour de l'année 10 00xx xx:1..365

Heure d'été,heure d'hiver

Année bissextile

11 yyxx xx: Heured'hiver = 00

Heure d'été =01

yy: Annéebissextile

Annéecourante = 00

Annéecourante - 1 =01



Tableau 18

09.99 Annexe


5.2.11.1 Zone de données d'heure CPU 944, CPU 945

Les numéros des mots de données sont un adressage relatif. La position réelle de la zone de donnéesest définie par les paramètres d'appel: UDAT = No DB, No DW de FB 86 : MELD:UHR.

Tableau 19Heure actuelle dans la zone de données de l'heure:

DW Mot/Gauche Mot/Droit

4 --- Jour de la semaine

6 Jour Mois

7 Année AM/PM (bit, No 7), heure

8 Minute Seconde

Figure 5Zone de réglage dans la zone de données d'heure:

Annexe 09.99



9 Année bissextile Jour de la semaine

10 Jour Mois

11 Année AM/PM (bit, No 7), heure

12 Minute Seconde

Figure 6

5.2.11.2 Zone de données d'heure CPU 928B, CPU 948


Figure 7

Heure actuelle dans la zone de données d'heure:


15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

4 Secondes 0

5 Format Heures Minutes

6 Jour du mois Jour de la semain 0

7 Année Seconde

Figure 8

Heure actuelle dans la zone de réglage:


15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

8 Secondes 0

9 Format Heures Minutes

10 Jour du mois Jour de la semain 0

Figure 9

09.99 Annexe


5.2.11.3 Zone de données d'heure CPU 946, CPU 947


Figure 10Heure actuelle dans la zone de données d'heure:


4 Dizaine s. 1ère décade s. 1/10 s. 1/100 s.

6 Dizaine h. 1ère décade h. Dizaine min. 1ère décade min.

7 Dizaine j. 1ère décade j. Jour de la semaine 0

8 Dizaine an 1ère décade an Dizaine mois 1ère décade mois

Figure 11

Heure actuelle dans la zone de réglage:


9 Dizaine s. 1ère décade s. 1/10 s. 1/100 s.

10 Dizaine h. 1ère décade h. Dizaine min. 1ère décade min.

11 Dizaine j. 1ère décade j. Jour de la semaine 0

12 Dizaine an 1ère décade an Dizaine mois 1ère décade mois

Figure 12

5.2.11.4 Format de données d'heure pour blocs d'alarmes

Les numéros des mots de données sont un adressage relatif. La position réelle de la zone de donnéesest définie par les paramètres: ZUHR = No DB, No DW de FB 86 : MELD:UHR.Il convient d'écrire les données DB 80, DW 190 dans les paramètres ZUHR si la fonctiond'"acquisition chronologique des alarmes" doit être utilisée avec le système d'alarmes S5.La date et l'heure sont fournies par le bloc fonctionnel FB 86 : MELD:UHR pour traitement del'alarme en code dual:Heure actuelle dans la zone de réglage:

Annexe 09.99


Signification Mot de données Bit Plage de valeur Remarque

1/100 seconde 1 0 - 6 0..99 (0 - 990ms)

période de 10ms

Secondes 1 7 - 12 0..59

Minutes 0 0 - 5 0..59

Heures 0 6 - 10 0..23

Jour 2 0 - 4 1..31

Mois 2 5 - 8 1..12

Année 2 9 - 15 0..127 (1990-2117)

Année + 1990

Figure 13

DW3: heure

DW4: heure

DW4: date

Figure 14

09.99 Annexe



Pour pouvoir utiliser la synchronisation de l’heure S5, l’utilisateur doit:

• renseigner les paramètres d'appel du FB 86 : MELD:UHR selon les indications du chapitreParamètres d'appel de FB 86 : MELD:UHR

• ouvrir les zones de données dans l'automate.

Exemple de configuration

Soit une CPU 944 à deux interfaces PG pour console de programmation. L'exercice consiste àconfigurer la synchronisation de l'heure S5 pour le système d'alarmes S5 sans l'heure radio DCF77.Zones de données:

Télégramme de synchronisation de l'heure: DB 100, DW 20 - DW 30

Zone de données de l'heure de l'horloge système S5: DB 100, DW 31 - DW 47

Données de blocs d'alarmes*: DB 80, DW 190 -DW 192

* Cette zone de données est imposée par le systèmed'alarmes SIMATIC S5.

Entrez dans le système le bloc de données souhaité (DB 100, DW20 - DW 30) pour "Synchronisationde l'heure" lors du paramétrage de canal (p. ex. SINEC H1).Attention à bien ouvrir les DW 0 à DW 255 du DB 80 et les DW 0 à DW 47 du DB 100.

Extrait du bloc OB 1:

Annexe 09.99


5.2.13 Interaction entre WinCC et le système d'alarmes

Notez les remarques ci-dessous concernant l'interaction entre le système d'alarmes WinCC et le blocd'alarmes S5:Vous devez entrer dans l'automate S5 la valeur 256 comme nombre de mots de données à transmettredans le bloc d'émission.Dans Control-Center, vous devez configurer une nouvelle liaison dans le canal S5Trsp. ParamétrezFetch-passiv pour liaison/fonction Read.Configurez deux variables de données brutes par automate pour l'échange de données avec le systèmed'alarmes.La première variable est pour la réception des alarmes.Configurez leur adressage comme suit: zone de données: DB, No DB: xx, adressage mot, DW: 0, typedonnées brutes: événementLa deuxième variable est nécessaire pour l'émission des informations d'acquittement.Configurez leur adressage comme suit: zone de données: DB, No DB: 80, adressage mot, DW: 90,type données brutes: événementLiez dans le système d'alarmes la variable d'événement à la variable de données brutes de réception(l'information de bit est ici sans signification).Liez dans le système d'alarmes la variable d'acquittement à la variable de données brutes d'émission(l'information de bit est ici sans signification).Configurez comme DLL de normalisation le fichier S5STD.NLL.Truc: l'assistant de connexion permet de lier d'un coup toutes les alarmes concernées.Seuls les nombres positifs à virgule fixe sont acceptés pour les valeurs de process. Les valeurs àvirgule flottante ne sont pas supportées.

09.99 Annexe


5.3 DLL de normalisation pour interfaage vers AlarmLogging etTagLogging

Fonction

Les applications AlarmLogging et TagLogging assurent l'acquisition des données de process via legestionnaire de données WinCC. En fonction du type de communication avec le process,

• diverses DLL de canal sont utilisées pour le transfert,

• les données de proces sont stockées dans les télégrammes (variables de données brutes) selon unestructure variable.

Or AlarmLogging et TagLogging doivent pouvoir traiter les données de process de la même manièrequel que soit le type de communication. C'est pourquoi on utilise pour chaque type de communicationune DLL de normalisation qui connaît exactement la structure des télégrammes et en dérive un formatde données de process accepté par AlarmLogging et TagLogging.Une DLL de normalisation est en principe rattachée à une DLL de canal et doit, tout comme celle-ci,pouvoir être ajoutée et supprimée de manière simple. La DLL de normalisation n'a cependant pasd'interface directe vers la DLL de canal correspondant.Cette page de documentation décrit l'incorporation et l'interface de chaque DLL de normalisation versles applications WinCC AlarmLogging et TagLogging. Cette documentation a été rédigée au momentdu développement de la DLL de normalisation S7PMC; le terme "DLL de normalisation S7PMC" doitêtre donc généralement compris au sens de DLL de normalisation en général.

Principe de fonctionnement

La DLL de normalisation S7PMC est un élément passif de programme ne possédant une interface quevers les applications AlarmLogging et TagLogging uniquement. La DLL de normalisation S7PMCtraite des fonctions spécifiques S7PMC pour AlarmLogging et TagLogging.AlarmLogging et TagLogging se déclarent à la DLL de normalisation par un appel de démarrage.Certains paramètres sont alors transmis par une structure de démarrage à la Norm.DLL et lespropriétés de celle-ci sont prises en compte via des codes.Deux sens de transfert de données sont nécessaires pour le traitement des fonctions S7PMC en moderuntime:

• OS vers automate: (envoi de contrats de déclaration/d'annulation de déclaration, acquittements)

• Automate vers OS: (réception d'alarmes et de données d'archive)TagLogging/AlarmLogging communiquent par un appel d'initialisation à S7PMC-DLL les noms desvariables d'archive et les numéros d'alarme configurés. La DLL de normalisation (WinCC) doit sedéclarer pour ces objets à l'automate. L'appel d'initialisation peut être exécuté à n'importe quelmoment.La DLL de normalisation est appelée par AlarmLogging/TagLogging pour désinitialisation afin derestituer des ressources, etc.

Annexe 09.99


5.3.1 Interface commune vers AlarmLogging et TagLogging

Les fonctions générales de la DLL de normalisation qui sont identiques pour AlarmLogging etTagLogging sont regroupées dans une interface commune. Les noms des fonctions commencent touspar ‘NORM...’.(Préfixe des fonctions spécifiques AlarmLogging: ‘Mld...’, préfixe des fonctions spécifiquesTagLogging: ‘Pde...’.)

MELD = AlarmLoggingPDE = TagLoggingCompléments spécifiques à AlarmLoggingRuntime

09.99 Annexe


Dialogue étendu de configuration

Annexe 09.99


5.3.2 Compléments spécifiques à TagLogging

Runtime

Dialogue étendu de configuration

09.99 Annexe


5.3.3 Fonctions API d’une DLL de normalisation WinCC

La DLL de normalisation est constituée des ensembles fonctionnels ci-dessous:

• Initialisation de la DLL de normalisation

• Initialisation par le système d'exploitation pendant le chargement de la DLL de normalisation(LibMain)

• Interrogation des propriétés d'une DLL de normalisation

• Interrogation du nom de la DLL de normalisation

• Fermeture de la DLL de normalisation

• Fermeture par TagLogging et AlarmLogging

• Déchargement par le système d'exploitation

• Extensions de la configuration

• Extension du dialogue pour la configuration des alarmes

• Extension du dialogue pour la configuration de variables d'archive

• Services en ligne

• Enregistrement de tous les objets spécifiques à la DLL de normalisation (alarmes, variablesd'archive)

• Changement de langue

• Normalisation

• Normalisation des alarmes

• Normalisation des variables d'archive

• Fermeture de la DLL de normalisation

Fermeture par TagLogging et AlarmLogging

TagLogging et AlarmLogging préviennent la DLL de normalisation lorsque les applications sontterminées. Dans la DLL de normalisation, les ressources sont restituées.NormDLLStop

Return Description

VRAI Fonction exécutée avec succès

FAUX Erreur dans fonction API

5.3.3.1 Initialisation de la DLL de normalisation

Initialisation pendant le chargement

Les applications AlarmLogging et/ou TagLogging chargent une DLL de normalisation WinCC à l'aidede l'appel système LoadLibrary. La DLL de normalisation est alors chargée par le systèmed'exploitation et initialisée par ses mécanismes standard. Toutes les adresses de point d'entrée de laDLL de normalisation sont définies.

Annexe 09.99


5.3.3.2 Interrogation des propriétés d'une DLL de normalisation

AlarmLogging et TagLogging se déclarent par l'appel NormDLLStart à la DLL de normalisation. Ceappel sert à l'échange d'informations entre la DLL de normalisation et l'application.NormDLLStart

Paramètres Description

lpUser Pointeur vers données d'application, transmission sans modification àCallback

bModeRuntime VRAI si la DLL de normalisation Norm.DLL est lancée en moderuntime, FAUX si elle est lancée en mode de configuration; pasexploité actuellement par Norm.-DLL

pcis Pointeur vers structure de démarrage

lpError Pointeur vers structure d'erreurs WinCC standard

Return Description

VRAI Aucune erreur

FAUX Erreur dans fonction API, description de la cause d'erreur par le pointeurlpError

NORM_STARTSTRUCT

Composant Description E/S

dwSize Taille de la structure en octets S

lpstrProjectPath Chemin du projet courant E

NORM_SEND_PROC

pfnWriteRwData

Ptr vers fonction Callback de l'application parlaquelle la DLL de normalisation envoie unevariable de données brutes à l'automate via legestionnaire de données (DM).

E

dwAppID Code application:

1 = AlarmLogging

2 = TagLogging

3 = USER (réservé pour autres aplications, pasutilisé actuellement)

E

dwLocaleID Langue courante au moment de l'appel E

dwNormCap Propriétés de la DLL de normalisation selontableau ci-dessous

S

La fonction Callback envoyant des variables de données brutes au gestionnaire de données WinCC estalimentée comme suit:

09.99 Annexe



lpDmVarUpdate Pointeur vers variable de données brutes

dwWait Code indiquant si l'application doit attendre ou pas la fin de l'appelpour écriture:

WAIT_ID_NO avec SET_VALUE

WAIT_ID_YES avec SET_VALUE_WAIT

lpUser Pointeur vers données d'application, stockées par mémento à l'appel deNormDLLStart


Return Description

VRAI Aucune erreur


Un bit du tableau ci-dessous est à affecter à chaque propriété.

DEFINE Masque de bits Signification

NORMCAP_DIALOG

0x00000001 activé La DLL denormalisationpropose un dialoguespécial

désactivé La DLL denormalisation nepropose pas dedialogue

NORMCAP_REENTRANT

0x00000002 activé La DLL denormalisation estréentrante

désactivé La DLL denormalisation n'estpas réentrante

NORMCAP_MSG_FREE_LOCK

0x00000004 activé Déclaration/Annulation de déclarationpossible pour lesalarmes.

désactivé Déclaration/Annulation de déclaration paspossible pour lesalarmes.

NORMCAP_ARC_FREE_LOCK

0x00000008 activé Déclaration/Annulation de déclarationpossible pourvariables d'archive.

Annexe 09.99



désactivé Déclaration/Annulation de déclaration paspossible pourvariables d'archive.

NORMCAP_MSG_GENERIC

0x00000010 activé Génération génériquepossible d'alarmes.

désactivé Génération génériqued'alarmes paspossible.

NORMCAP_ARC_GENERIC

0x00000020 activé Génération génériquede variables d'archivepossible.

désactivé Génération génériquede variables d'archivepas possible.

5.3.3.3 Interrogation du nom de la DLL de normalisation

NormGetDLLName

Return Description

LPTSTR Pointeur vers une chaîne de caractères contenant le nom en clair de la DLL denormalisation; le nom est fonction de la langue courante.

09.99 Annexe


5.3.4 Fermeture de la DLL de normalisation

5.3.4.1 Extensions de la configuration

Des actions de configuration spécifiques aux objets S7PMC sont nécessaires. Les paramètres sont toutd'abord demandés dans un dialogue par des moyens standard (sans MFC) et sont transférésdirectement dans le numéro d'alarme WinCC ou dans le nom des variables d'archive. Ainsi, la DLL denormalisation n'a pas à enregistrer et à gérer elle-même ces données. Pour que le numéro d'alarme ouune variable d'archive soit unique, une correspondance binunivoque doit exister entre le numérod'alarme ou la variable d'archive et la variable de données brutes correspondante. Cette informationd'affectation fait partie du numéro d'alarme ou du nom de variable d'archive.

5.3.4.2 Extension du dialogue pour la configuration des alarmes S7PMC

La DLL de normalisation comporte une fonction API pour la configuration des numéros d'alarmespécifiques aux objets S7PMC. Cette fonction est appelée par le système de configuration d'alarmesCS lors du paramétrage des alarmes individuelles rattachées à une DLL de normalisation S7PMC. LaDLL de normalisation S7PMC attribue le numéro d'alarme constitué de deux parties:

Partie 1:

Numéro unique identifiant une CPU d'automate dans tout le projet (numéro de variable de donnéesbrutes)

Partie 2:

Numéro faisant partie de l'alarme côté automate et identifiant de manière univoque cette alarme dansune CPU d'automate (spécifique à la DLL de normalisation)Vous devez, pour former le numéro d'alarme, effectuer la sélection suivante dans le dialogue deconfiguration:Structure d'un numéro d'alarme S7PMC (32 bits)

Partie 1

Chaque alarme est rattachée à une variable de données brutes identifiant une CPU d'automate. Pourréaliser la correspondance variable de données brutes - numéro d'alarme, une convention a étéadoptée.Le nom de la variable de données brutes pour S7PMC - et pour tous les types de liaison utilisant uneDLL de normalisation - a la structure invariable suivante:@rd_alarm#rd_nr

@rd_alarm# Partie fixe du nom d'une variable de données brutes pour les DLL de normalisation

rd_nr Nombre entre 0 et 1023 identifiant une variable de données brutes (sans zéros de tête)

Le bit ayant le poids le plus fort du numéro de l'alarme est à 1 pour les numéros d'alarme attribués (enexterne) par les DLL de normalisation. Ces alarmes ne doivent être traitées que par les DLL denormalisation correspondantes, c'est-à-dire que le numéro d'alarme ne peut être modifié dans ledialogue de configuration d'AlarmLogging.

Annexe 09.99


Partie 2

Cette partie du numéro d'alarme peut être remplie par la DLL de normalisation correspondante. Elle apour S7PMC la signification suivante:

MKl Classe d'alarmes; Choisir une des classes:SCAN (1)ALARM/NOTIFY(2)ALARM_8P/ALARM_8 (2)LTM (3)

Sub-Nr Sous-numéro d'alarme uniquement pour ALARM_8 et ALARM_8P:1...8

PMC-ID Numéro d'alarme PMC (Paramètres transmis bloc de données EV-ID):1...16386pour classe d'alarmes SCAN et ALARM/NOTIFY et ALARM_8P/ALARM_81...7 pour classe d'alarmes LTM

MldShowDialog


hwnd Poignée de fenêtre (handle)

lpmCS Pointeurs vers données d'alarme individuelle

lpDMProjectInfo Pointeur vers structure d'informations de projet

lpError Pointeur vers la structure d'erreurs standard WinCC

Return Description


FAUX Erreur dans fonction API; description de la cause d'erreur par lepointeur lpError

5.3.4.3 Extension du dialogue de configuration de variables d’archive

La DLL de normalisation comporte une fonction API pour la définition des noms de variablesd'archives spécifiques S7PMC. Cette fonction est appelée par TagLogging CS lors du paramétrage desvariables d'archive appartenant à une liaison S7PMC. La DLL de normalisation S7DMC attribue unnom de variable d'archive constitué de plusieurs éléments et comprenant entre autres le numérorattaché à l'archive côté automate. Par cet algorithme, les numéros d'archive S7PMC sont contenusdans la description de variables d'archive WinCC et uniques, ce qui permet une affectationextrêmement rapide au runtime.TagLogging garantit que les noms de variables d'archive sont globalement uniques.Structure d'un nom de variable d'archive S7PMC (longueur maxi 18 octets)

09.99 Annexe


Désignation Longueur enoctets

Attribution par Signification

aspiration 9 TagLogging Chaîne de caractères fixes attribuée parTagLogging, constituée du nom de laDLL de normalisation et du caractère #comme séparateur, p. ex. pour S7PMC:NRMS7PMC n'est pas affiché parl'interface utilisateur

rw_id 8 TagLogging/

Norm.DLL

Identificateur de données brutes encaractères hexadécimaux (zéros de têteinclus); ceci permet une affectationunivoque aux variables de donnéesbrutes (liaison) à laquelle est rattaché lenuméro d'archive. La partie nom estformée par la DLL de normalisation àl'aide des paramètres transmis parTagLogging.

x 1 Norm.DLL-

Partie CS

Code spécifique S7PMC servant àdifférencier BSEND et AR_SEND:

‘A’ = AR_SEND

‘B’ = BSEND

ar_id 4 Norm.DLL-

Partie CS

Identificateur hexadécimal (zéros detête inclus)

Fonction du code x:

Numéro d'archive spécifique S7PMCAR_ID ou

R_ID spécifique S7 pour BSEND

Exemple d'un nom de variable d'archive créé pour S7PMC: #00000001#A#0014PdeShowDialog


hwnd Poignée de fenêtre (handle)

lpszArcVarName Pointeur vers champ de chaîne de caractères pour stockage de la partiedu nom de variable d'archive spécifique à la DLL de normalisation

dwArcVarNameLength

Longueur maxi de la partie du nom spécifique à la DLL denormalisation

lpVarKey Pointeur vers Varkey de la variable de données brutes

lpError Pointeur vers structure d'erreurs de WinCC

Return Description


FAUX Erreur dans fonction API, description de la cause d'erreur par lepointeur lpError

Annexe 09.99


5.3.4.4 Services en ligne

Enregistrement de toutes les alarmes

Cette fonction est nécessaire parce que la DLL de normalisation ne possède aucune information deconfiguration sur les alarmes qui sont pertinentes. Les alarmes ne sont envoyées par l'automate quelorsque l'application (WinCC) s'est déclarée prête à recevoir les alarmes. En l'état actuel des choses,AlarmLogging appelle la fonction MldRegisterMsg pour chaque alarme pertinente et transmet ainsiles informations de configuration à la DLL de normalisation pour l'alarme individuelle. La DLL denormalisation reçoit, avec la description de l'alarme, un pointeur vers la variable de données brutes(liaison) à laquelle cette alarme est rattachée. Ainsi, la DLL de normalisation peut créer au runtime untableau dans la mémoire vive servant à composer les télégrammes de déclaration spécifiques S7PMC.MldRegisterMsg


lpDMVarKey Pointeur vers Varkey de la variable de données brutes

lpMsgNumber Pointeur vers champ contenant les numéros d'alarmes individuelles

dwNumMsgNumber Nombre des numéros d'alarmes individuelles


Return Description



09.99 Annexe


5.3.4.5 Enregistrement de toutes les variables d’archive

Cette fonction est nécessaire parce que la DLL de normalisation ne possède aucune information deconfiguration sur les variables d'archive pertinentes. C'est pourquoi la fonction PdeSendMsg estappelée, pour un nombre défini de variables d'archive pertinentes, pour communiquer à la DLL lesinformations de configuration et les informations supplémentaires TagLogging pour les variablesd'archive.Il est possible d'enregistrer plusieurs variables d'archive d'une liaison en un seul appel.Pour chaque variable d'archive, TagLogging transmet un double-mot d'information supplémentaire àla DLL de normalisation; cette information est stockée dans la mémoire de la DLL de normalisation.Cette information supplémentaire est nécessaire à TagLogging dès que des valeurs de variablesd'archive doivent être traitées (dans la fonction Callback TagLogging_ARCHIVE_CALLBACK).Ainsi, la DLL de normalisation peut créer au runtime en mémoire vive un tableau servant à former lestélégrammes d'enregistrement spécifiques S7PMC pour les diverses archives. Les télégrammesd'enregistrement sont nécessaires pour communiquer à l'automate que WinCC est prêt à recevoir lenuméro d'archive. L'automate n'envoie les données d'archive à l'application (WinCC) que lorsquel'enregistrement s'est déroulé avec succès.PdeSendMsg

Annexe 09.99



lpfnCallBack Pointeur vers routine Callback transmettant au gestionnaire dedonnées la variable de données brutes formée par la DLL denormalisation.

Si valeur est 0, la routine Callback est appelée depuis la structureIni.

L'adresse de fonction de la structure Ini n'est pas identique à ceparamètre.

dwFunctionId Code de fonction FUNC_ID_REGISTER (voir tableau ci-dessous); même fonction pour toutes les variables décrites

lpszArcVarName Pointeur vers un tableau de pointeurs dont les éléments renvoientaux noms des variables d'archive

lpdwData Pointeur vers un tableau dont les éléments contiennent desinformations supplémentaires pour les variables d'archive. Valeurnulle également possible.

La valeur supplémentaire rattachée à une variable d'archive estreprise telle quelle par la fonction FUNC_ID_REGISTER(enregistrement de variable d'archive) dans des listes internes dela DLL de normalisation et passée en temps voulu à la fonctionTagLogging_ARCHIVE_CALLBACK.

Sans utilité pour les autres codes de fonction.

dwNumArchVarName Nombre des noms de variables d'archive à traiter

lpVarKey Pointeur vers Varkey de la variable de données brutes

lpUser Pointeur vers données utilisateur, transmission sans modificationà Callback


Return Description



Fonctions possibles de la procédure PdeSendMsg (valeurs de dwFunctionId):


FUNC_ID_LOCK

0x00000001 Verrouillage de variable d'archive

FUNC_ID_FREE

0x00000002 Déverrouillage de variable d'archive

FUNC_ID_REGISTER

0x00000004 Enregistrement de variable d'archive

FUNC_ID_UNREGISTER 0x00000008 Suppression d'enregistrement devariable d'archive (fonction pas utiliséeactuellement)

09.99 Annexe


5.3.4.6 Changement de langue

Le dialogue de configuration doit être spécifique à la langue utilisée: la DLL de normalisation doitconnaître la langue paramétrée. La langue paramétrée est communiquée au démarrage par la structurede démarrage. Le changement dynamique de langue doit être passé par TagLogging et AlarmLoggingaussi à la DLL de normalisation. Ceci se fait par l'appelNormSetLanguage


dwLocaleID Langue courante au moment de l’appel

lpError Pointeur sur structure d’erreurs WinCC standard

Return Description



Annexe 09.99


5.3.5 Normalisation

Les applications qui se sont déclarées à l'automate programmable prêtes à recevoir des alarmes ou desdonnées d'archive reçoivent celles-ci par la variable de données brutes correspondante. La DLL denormalisation exécute la déclaration au moment de l'enregistrement. A partir de cet instant, l'automatepeut émettre des télégrammes de données. Les télégrammes de données sont empaquetés dans desvariables de données brutes et tranmis, via la DLL de canal, le gestionnaire de données et l'applicationcorrespondante (en l'occurence TagLogging ou AlarmLogging), à la DLL de normalisationcorrespondant au type des variables de données brutes. La DLL de normalisation interprète lesdonnées reçues et génère les alarmes ou données d'archive à partir de celles-ci.

5.3.5.1 Dérivation d'alarmes individuelles

Une variable de données brutes (d'un télégramme) peut contenir n alarmes individuelles. La DLL denormalisation doit interpréter le télégramme spécifique S7PMC et transmettre à AlarmLogging lesalarmes individuelles qui en résultent.Le numéro d'alarme de S7PMC (EV_ID) est un élément du numéro d'alarme WinCC.Une alarme peut être transmise par S7PMC avec jusqu'à 10 valeurs de process, le type "Chaîne decaractères" étant accepté comme valeur de process. Ce type de valeur de process n'est cependant passupporté par AlarmLogging, et la DLL de normalisation doit rejeter ces valeurs suplémentaires.La fonction MldReceiveMsg est appelée par AlarmLogging chaque fois que l'état de la variable dedonnées brutes est modifié, c'est-à-dire lorsque le gestionnaire de données constate un changementd'état Incident -> OK ou inversement. La modification de l'état de la variable de données brutes(correspond à une liaison) a une importance pour la DLL de normalisation S7PMC. Pour de plusamples informations, se reporter au chapitre "Traitement au changement d'état".MldReceiveMsg


lpfnMsgReceive Pointeur vers routine Callback transmettant l’alarme individuelleformée par la DLL de normalisation à AlarmLogging.

lpDMVar Pointeur vers variable de données brutes

lpUser Pointeur vers données utilisateur, transmission sans modification àCallback


Return Description



La fonction Callback assurant le passage des alarmes individuelles à AlarmLogging est alimentéecomme suit:

09.99 Annexe



lpMsgCreate Pointeur vers alarme WinCC

dwNumMsg Nombre des alarmes individuelles

lpUser Pointeur vers données d'application


Return Description



5.3.5.2 Acquittement, verrouillage, déverrouillage d'alarmes

Le concept d'alarmes et d'acquittement de WinCC-AlarmLogging et de S7PMC prévoit la possibilitéd'acquitter les alarmes en fonction de leur configuration. L'information d'acquittement est connued'AlarmLogging, mais doit être également gérée dans la mémoire d'acquittement d'alarmes del'automate. Pour cela, AlarmLogging envoie des télégrammes d'acquittement à l'automate par la DLLde normalisation correspondant à la liaison.A l'aide des données reçues, la DLL de normalisation S7PMC construit les télégrammes S7PMCcorrespondants qui sont transmis au gestionnaire de données par la fonction Callback d'AlarmLoggingNORM_SEND_PROC.La même procédure est utilisée pour le verrouillage/déverrouillage par AlarmLogging d'une alarmeindividuelle: la génération de l'alarme est inhibée à la source dans l'automate / est débloquée.MldSendMsg


lpfnMsgSend Pointeur vers la routine Callback d’AlarmLogging transmettant la variablede données brutes formée par la DLL de normalisation pour l'écriture decette variable dans l'automate. Les paramètres sont décrits au chapitre"Interrogation des propriétés d'une DLL de normalisation"

lpSendData Pointeur vers données transmises; structure décrite ci-après

dwNumData Nombre des contrats individuels à traiter



Return Description



Structure des données passées AlarmLogging (contrat unique)

Annexe 09.99


Variable Signification

DWORD dwVarID Variable de données brutes - ID du gestionnaires de données

DWORD dwNotify Notify Valeurs possibles

MSG_STATE_QUIT Acquittement d'alarme

MSG_STATE_LOCK Verrouillage d'alarme

MSG_STATE_UNLOCK Déverrouillage d'alarme

MSG_STATE_QUIT_EMERGENCY Acquittement de toutes lesalarmes

DWORD dwData dans QUIT, LOCK, UNLOCK --> Numéro d'alarme

dans NOTQUIT --> non utilisé

5.3.5.3 Traitement au changement d'état

Le changement d'état d'une liaison (variables de données brutes) doit être communiqué à la DLL denormalisation. Ceci se fait avec la fonction MldReceiveMsg.

Changement De - Vers Traitement dans la DLL de normalisation S7PMC

Incident -> OK Envoi à l'automate de télégrammes de déclaration pour toutesles classes d'alarme S7PMC pour lesquelles une alarme aumoins a été configurée La déclaration est exécutée de manièrespécifique aux classes d'alarme S7PMC.

La DLL de normalisation connaît déjà par leur enregistrementtoutes les alarmes configurées.

OK -> Incident La DLL de normalisation doit rejeter les contrats actifs déjàenvoyés à l'automate, mais qui, en raison du changement d'état,n'ont pu être exécutés complètement (il manque desacquittements).

5.3.5.4 Mise à jour d'alarmes par la DLL de normalisation S7PMC

Lors de la mise à jour d'alarmes, la DLL de normalisation S7PMC lit l'état de toutes les alarmes dontelle a connaissance par l'enregistrement et envoie cet état sous forme d'une alarme individuelle àAlarmLogging. Ceci permet d'avoir au démarrage du système une vue des alarmes cohérente.Une mise à jour d'alarmes est nécessaire quand

• un changement d'état Incident -> OK a été détecté (c'est implicitement le cas au démarragesystème)

• l'automate envoie un télégramme de mise à jour d'alarmes. Ce télégramme est envoyé à chaquestation déclarée, p. ex. lorsqu'un débordement d'alarmes est constaté, lorsque des alarmes sontacquittées par d'autres stations ou déverrouillées.

A la mise à jour d'alarmes, l'automate envoie les états d'acquittement d'alarmes et les codes deverrouillage. Les valeurs supplémentaires et l'heure des alarmes ne sont pas transmises. La DLL denormalisation fournit alors l'heure système courante à l'heure de l'alarme individuelle et intègre dansl'état de l'alarme le code MSG_STATE_UPDATE par la fonction Logic OU.

5.3.5.5 Normalisation de variables d’archive

La DLL de normalisation contient deux fonctions pour TagLogging:

• dérivation de valeurs de variables d'archives du contenu d'une variable de données brutes

• verrouillage / déverrouillage de variables d'archive

09.99 Annexe


5.3.5.6 Dérivation de valeurs de variables d'archives

Une variable de données brutes (d'un télégramme) peut contenir n valeurs de variables d'archive. LaDLL de normalisation doit interpréter ce télégramme spécifique S7PMC et transmettre à TagLoggingles valeurs de variables d'archive qui en résultent.Des convertisseurs de valeurs de process peuvent être envoyés avec une archive. La DLL denormalisation S7PMC effectue alors la conversion souhaitée de la valeur de process en valeur devariable d'archive. Les fonctions de mise à l'échelle existant déjà dans WinCC peuvent être utiliséespour cela. La procédure exacte à suivre doit encore être définie.La fonction PdeReceive est appelée par TagLogging chaque fois que l'état des variables de donnéesbrutes a été modifié: lorsque le gestionnaire de données constate le passage de l'état Incident à l'étatOK ou inversement. La modification de l'état de la variable de données brutes (correspond à uneliaison) a une importance pour la DLL de normalisation S7PMC. Pour de plus amples informations, sereporter au chapitre "Traitement au changement d'état".PdeReceive


lpDmVarUpdate Pointeur vers variable de données brutes

lpfnCallBack Pointeur vers routine Callback par laquelle la DLL de normalisationtransmet à TagLogging les valeurs de variables d'archive.



Return Description



La fonction Callback permettant le passage des différentes valeurs de variable d'archive à TagLoggingsuit la procédure suivante:

Annexe 09.99



lpszArcVarName Nom de variable d'archive à partir de l'identificateur de données brutes

doValue Valeur de variable d'archive

lpstTime Pointeur vers time stamp dont les données utiles de la variable dedonnées brutes sont dérivées

dwFlags Codes dont la signification exacte reste encore à définir

dwData Donnée transmise avec autres données à l'enregistrement de la variabled'archive; à transmettre telle quelle

lpUser Pointeur vers données utilisateur; reprise sans modification par l'appelde fonction


Return Description



5.3.5.7 Verrouillage / déverrouillage de variables d'archive

Par cette fonction, TagLogging exploite la possibilité offerte par S7PMC de piloter la réception desvaleurs de variables d'archive. La DLL de normalisation S7PMC construit un appel pour annuler ladéclaration ou redéclarer l'archive correspondante et transmet cet appel au gestionnaire de données parla procédure NORM_SEND_PROC.Le verrouillage / déverrouillage de variables d'archive est, du point de vue de la DLL de normalisationS7PMC, pratiquement identique aux fonctions qui sont utilisées pour l'enregistrement d'une variabled'archive. Pour les deux fonctions, c'est la même fonction qui est appelée dans la DLL denormalisation PdeSendMsg.Le code de fonction dwFunctionId permet la distinction entre verrouiller / déverrouiller: les donnéessupplémentaires de variable d'archive lpdwData n'ont aucune signification pour le verrouillage et ledéverrouillage. Voir chapitre "Enregistrement de toutes les variables d'archive"

5.3.5.8 Traitement au changement d'état

Le changement d'état d'une liaison (variables de données brutes) doit être communiqué à la DLL denormalisation via la fonction PdeReceive.

Changement De - Vers Traitement dans la DLL de normalisation S7PMC

Incident - OK Télégramme d'enregistrement de toutes les variables d'archivede toutes les liaisons

La DLL de normalisation connaît déjà par leur enregistrementtoutes les variables d'archive configurées.

Incident - OK La DLL de normalisation doit rejeter les contrats actifs déjàenvoyés à l'automate, mais qui, en raison du changement d'état,n'ont pu être exécutés complètement (il manque desacquittements).

09.99 Annexe


5.4 Bibliothque globale

Annexe 09.99


5.4.1 Blocs de process

5.4.1.1 Moteurs

09.99 Annexe


5.4.1.2 PC /API

5.4.1.3 Pompes

Annexe 09.99


5.4.1.4 Tuyauterie

5.4.1.5 Tuyauterie – Objets utilisateur

09.99 Annexe


5.4.1.6 Cuves

5.4.1.7 Robinet objets utilisateur

5.4.1.8 Robinets

Annexe 09.99


5.4.2 Affichage

5.4.2.1 Affichage

5.4.2.2 Fenêtres

5.4.2.3 Echelle

5.4.2.4 Champs de texte

09.99 Annexe


5.4.2.5 Instruments à index

Annexe 09.99


5.4.3 Commande

5.4.3.1 Boutons tridimensionnels

5.4.3.2 Pupitres de commande

09.99 Annexe


5.4.3.3 Boutons de vue

5.4.3.4 Navigation dans vue

Annexe 09.99


5.4.3.5 Boutons Incr./Décr.

5.4.3.6 Régulateurs

5.4.3.7 Changement de langue

5.4.3.8 Claviers

09.99 Annexe


5.4.3.9 Boutons de basculement

Annexe 09.99


5.4.4 Symboles

5.4.4.1 Robinets d’isolement

09.99 Annexe


5.4.4.2 Registres

Annexe 09.99


5.4.4.3 DIN 30600

09.99 Annexe


5.4.4.4 Symboles E

Annexe 09.99


5.4.4.5 Bandes transporteuses

09.99 Annexe


5.4.4.6 Symboles ISA

5.4.4.6.1 Isa_s55a

5.4.4.6.2 Isa_s55b

Annexe 09.99


5.4.4.6.3 Isa_s55c

5.4.4.6.4 Isa_s55d

5.4.4.6.5 Isa_y32a

09.99 Annexe


5.4.4.6.6 Isa_y32b

5.4.4.6.7 Isa_y32c

5.4.4.6.8 Isa_y32d

Annexe 09.99


5.4.4.6.9 Isa_y32e

5.4.4.6.10 Isa_y32f

5.4.4.6.11 Isa_y32g

5.4.4.6.12 Isa_y32h

09.99 Annexe


5.4.4.6.13 Isa_y32i

5.4.4.7 Moteurs

Annexe 09.99


5.4.4.8 Robinets

09.99 Annexe


5.4.4.9 Divers

Annexe 09.99


5.4.4.10 Divers 2

09.99 Index

WinCC Configuration Manual Index-1C79000-G8277-C157-01

Index

AAccès, 3-52

A la base de données, 3-52, 3-63Autorisations, 3-58

Access, 5-9Lecture de donnnées WinCC, 5-9

AcquitterAlarmes, 3-81

Actions, 3-24, 4-11Créer, 4-3, 4-13Cycles de rafraîchissement, 3-27Dans WinCC, 4-4Définir, 3-9Editeur de, 4-11Modifier, 4-11Rafraîchissement des vues, 3-24Répertoire, 3-46Réutiliser, 3-62, 4-11Sélection, 3-32

ActiveX, 2-2, 2-3, 3-54, 3-97Adaptation, 3-24

Données pour importation de variables, 3-69Propriétés de l'ordinateur, 3-55Rafraîchissement de vue, 3-24

Addition, 4-29Adressage, 3-6

Indirect, 3-6, 3-91Alarme, 3-20

Dans le concept de commande, 3-15Généralités sur la convention, 3-20

Alarmes, 2-4Alarmes au fil de l'eau, 3-20Définition des couleurs, 3-17Fichier d'alarmes, 3-72Lecture, 3-71Messages système, 3-42Procédure de signalisation, 3-20Réutiliser, 3-70, 3-71Sauvegarde, 3-53Signalisation binaire, 3-20Vue d'alarme, 3-82

ANSI, 4-3API, 2-4, 3-63, 3-64, 3-99Application, 2-2, 3-23

Fermer, 3-49Intégrations d'autres, 2-3Interface (API), 3-63Propres, 2-2

Archivage, 3-2, 3-53Configurer, 3-56Temps d'archivage, 3-23

Archiveutilisateur, 3-74

Archive utilisateur, 3-57, 3-99

Réutiliser, 3-74Archiver, 2-2Assistant, 3-71

Dans objets utilisateur, 3-92Dynamisation d'objets, 3-39Fichiers du répertoire par défaut, 3-43Lecture de variables S5 / S7, 3-63Lectures des messages Coros, 3-71Rafraîchissement de vue, 3-24Réutiliser script, 3-99

Au fil de l'eau, 3-20Signalisation, 3-20

Autorisation, 3-54

BBarre d'outils, 3-81

Alarm Logging, 3-81, 3-83Tag Logging, 3-84

Base, 3-56Pour importation, 3-66Projet de base, 3-56, 3-74

Base de données, 2-4Accès avec Access, 5-9Accès avec Excel, 5-6Accès avec ISQL, 5-10Accès avec Scope, 5-11Langage d'interrogation, 2-4Modification, 3-56Reconstruction, 3-44Sauvegarde, 3-52Sélection dans, 5-13

Basic, 2-2, 3-98Basic Process Control, 3-16, 3-78, 3-83Bibliothèque, 3-53

Projet, 3-53, 3-60, 3-61Standard, 3-43Texte, 3-70

Bibliothèque utilisateur, 3-78Bitmap, 3-59

Réutiliser, 3-59Boîte de boutons d'option, 3-80

Commande par clavier, 3-80Boucle, 4-47

Do while, 4-47For, 4-48While, 4-47

CCanal, 3-54

DLL, 3-54, 3-64, 3-69S7 PMC, 3-100

C-API, 2-4Caractères, 4-40

Index 09.99

Index-2 WinCC Configuration ManualC79000-G8277-C157-01

Admissibles dans noms de projet, 3-4Admissibles dans noms de variable, 3-6Admissibles dans noms de vue, 3-7Séquence, 4-40

Caractères spéciaux, 3-7Chaîne de caractères, 4-40Clavier, 3-15

Commande, 3-15, 3-38, 3-75Touche de raccourci, 3-86Touches de fonction, 3-78

Client, 2-4Commande, 3-11, 3-15, 3-18

Commande événementielle, 3-18Erreur de conduite, 3-10Fenêtre de courbes, 3-84Par clavier, 3-38, 3-78Par touches de fonction, 3-76Sans souris, 3-75

Communication, 3-18, 3-27, 3-58Entre les tâches, 3-27Influence sur le rafraîchissement, 3-27Interfaces, 3-54Modifier en ligne, 3-100Process, 3-23

Composants, 3-88Préconfiguré, 3-60Technique des composants de vue, 3-88

Concept, 2-4, 3-11Commande, 3-11, 3-15Sauvegarde des données, 3-51Vues prototypes, 3-89

Concept de commande, 3-15Conditionnelle, 4-47

Instructions, 4-47Configuration, 3-24, 3-46

Conventions pour, 3-2Dialogue, 3-24, 3-29, 3-40, 3-54, 3-59, 3-92Données de, 3-46Dynamisation, 3-40Mode, 3-48

Connexion, 3-87, 3-100Contenu, 3-46

Répertoires de projet, 3-46Contrôles de licence, 3-42Conversion, 3-57

Monoposte - Multiposte, 3-57Coros, 3-71Couleur

Couleurs du projet, 3-11Définition, 3-17Reconnaissance, 3-11

Couplage, 3-18Au process, 3-18Onduleur, 3-51Série avec CP525, 5-14

CourbesCommandes de fenêtre, 3-81, 3-84Réutiliser cadre, 3-57

Créer, 4-114

Fichier avec script, 4-114Structure d'alarme, 3-73

Curseur, 3-15, 3-79Curseur, 3-15, 3-79Pointeur, 3-15, 3-79

Cycle, 3-24, 3-27, 3-35Cycle utilisateur, 3-26, 3-35

DD'alarme, 3-17

Classe dálarmes, 3-17, 3-72Liste d'alarmes, 3-81Système d'alarmes, 3-17

DDE, 2-2Déclaration, 3-44

OCX, 3-44, 3-98OLE, OCX, 3-54

Déclenchement en fonction du temps, 3-34Déclencheur, 3-24

Dans le dialogue de dynamisation, 3-32Dans les actions C, 3-32Déclenchement en fonction d'une variable,3-27En fonction du temps, 3-35Rafraîchissement de vue, 3-24Variables, 3-24

Déconnexion, 3-87, 3-100Décrémenter, 4-29Définition, 4-65

Structures en C, 4-65Définitions, 2-5Démarrage, 3-48

Automatique, 3-48Automatique de WinCC, 3-48Messages système au, 3-42

Démarrage automatique, 3-48Entrée dans le dossion, 3-48

Désactiver, 3-80Curseur de runtime, 3-80

Développement, 2-2Diagnostic, 3-66, 4-16

Fichier d'importation, 3-66Fichiers, 3-42Scope, 5-5

Dialogue, 3-40Configuration, 3-24, 3-40, 3-59

Dialogue de dynamisation, 3-24, 3-27, 3-39Division, 4-29Documentation, 3-2Données, 3-4

Dans la base de données, 3-44Données de configuration, 2-4Données de la base de données, 2-4Gestion de données, 2-4Importer, 3-52Rafraîchir, 3-18Rangement des données, 3-4, 3-21

09.99 Index


Requérir, 3-23Réutilisation, 3-56Réutilisation de S5 ou S7, 3-63Sauvegarde, 3-53Séparation, 3-45

Données de configuration, 2-4Données de process, 2-2, 2-4, 3-23

Archiver, 2-2Dynamic-Wizard, 3-24, 3-30, 3-39, 3-63, 3-88, 3-92Dynamique, 3-38

Instance, 3-93Liaison des variables, 3-91Modification des propriétés de l'objet, 3-38

Dynamisation, 3-92Configurer, 3-40Dans WinCC, 3-38Evénement, 3-39Objet utilisateur, 3-92Objets, 3-39Propriétés, 3-38Type, 3-28Types, 3-24

Ee

Normali, 5-3Editeur, 4-11EN 60073, 3-17En ligne, 3-99

Configuration, 3-99Entrée de commandes

Fenêtre d'alarmes, 3-81Fenêtre de courbes, 3-84Fonctions avec protection d'accès, 3-50Objets de commande, 3-79

Environnement de développement, 3-46, 3-98,4-3Erreur, 3-45

Erreur de conduite, 3-45Message d'erreur, 3-55Recherche, 3-42, 4-11

Etat, 3-20A la fermeture, 3-48Affichage d'état, 3-11Indicateur d'état, 3-59Modification, 3-20

Etiquette, 3-14Evénement, 3-39

Commandé, 3-18Déclencheur, 3-24, 3-34, 3-36Dynamisation, 3-39En-tête de la fonction, 4-5

Excel, 3-6, 3-21, 3-66, 3-68, 3-71, 3-73, 5-6Lecture de données avec MSQuery, 5-6

Exécuter, 3-66De scripts, 3-34

Importation, exportation de variables, 3-66Exemple de projet, 3-13, 3-56

Langue, 3-3Résolution d'écran, 3-13

Exportation, 3-6, 3-44, 3-52, 3-61, 3-66Exportation de données, 5-12

Par action C, 5-12Extension, 3-62

Fichiers WinCC, 3-46Pour actions, 3-62

FFenêtre, 4-16

Changement de fenêtre, 3-81Cycle, 3-25, 3-27, 3-33Diagnostic, 4-16

Fenêtre d'alarmes, 3-57, 3-81, 3-84Fenêtre d'application, 2-3, 3-57, 3-81, 3-84Fenêtre de tableau, 3-57, 3-84Fermeture, 3-51Fichiers, 3-45

Dans le répertoire de projet, 3-45Dans le répertoire par défaut, 3-42

Float, 4-18Fonction Callback, 5-62

Retour d'information d'état d'un contratd'écriture, 5-62Valeur de process lue pour transfert, 5-62

Fonctionnalité, 3-94Barre d'outils Alarm Logging, 3-83Barre d'outils Tag Logging, 3-85Composants de vue, 3-94

Fonctions, 3-63API, 3-63Commande, 3-19Créer, 4-12Dans WinCC, 4-4Editeur, 4-11En-tête, 4-5Interne, 3-27, 4-11Projet, 3-46, 4-11Protection d'accès, 3-50Réutiliser les fonctions de projet, 3-74Standard, 3-42, 3-74, 4-11Structure, 4-5

GGénérer, 3-55

Créer en-tête, 3-55Nouvel en-tête, 3-58, 3-74, 3-96

Graphique, 3-90Bibliothèque, 3-90Utilitaires, 3-44

Groupe, 3-19Groupe de variables, 3-5

Index 09.99


Groupe d’utilisateurs, 3-19, 3-74Groupes d’utilisateurs, 3-58

Groupe cible, 4-1

HHiérarchie, 3-15

Commande, 3-15Installations, 3-76Vue, 3-78

hnStar, 5-60

IIF, 4-48IHM, 2-2, 2-5, 3-18, 3-48Importation, 3-6, 3-52, 3-63, 3-66Impression

Affichage du test, 4-14Incrémenter, 4-29Information, 3-11

Dans la vue, 3-10Masquer, 3-11Rechercher, 3-4

Informix, 2-4Ingres, 2-4Initialisation d'une unité de canal, 5-62

Paramètres du gestionnaires de donnéesWinCC, 5-62

Installation, 3-44Utilitaires, 3-44WinCC, 3-54

Instance, 3-93Créer, 3-93

Instruction, 4-47Conditionnelle, 4-47

Instrument à index, 3-11, 3-92Intégrer, 3-88

OCX, 3-88Interface, 3-63

API, 3-63Interface de programmation, 2-4Interface utilisateur, 2-3, 3-2, 3-10

Définir, 3-10Interne, 3-27

Fonctions, 3-27, 3-42

LLangue, 3-70

Réutiliser, 3-70Lecteur, 3-52

De sauvegarde de données, 3-52Lecture, 3-71

Alarmes, 3-71Liaison, 3-100

Avec variables, 3-91Avec variables de process, 3-96Configurer, 3-100Indirect, 3-88Liste des liaisons, 3-68Logique, 3-63Nouvelle, 3-88

Liaison directe, 3-24, 3-39, 3-79, 3-90, 3-95Liste d'affectations, 3-63Log, 3-42

Fichiers, 3-42, 3-47Logique, 4-30

Comparaison, 4-30

MMasquer, 3-11

Des informations, 3-11Mémoire, 4-40Modèle, 3-3, 3-94

Fenêtre d'alarmes, 3-82Propres projets, 3-3Vues, 3-94

Modifier, 3-26Avec déclenchement en fonction d'unevariable, 3-28Cycle de fenêtre, 3-33Cycle de vues, 3-33Cycle utilisateur, 3-26Déclencheur, 3-32Etats, 3-38Propriétés du projet, 3-55

Modularité, 2-2Modules, 2-2

Intégrer, 2-2Monoposte, 3-13, 3-56

Système, 3-13, 3-51, 3-56, 3-57Mot de passe, 3-19, 3-50, 4-11Multiclient, 3-57Multiplication, 4-29

NNombre, 4-18

Nombre à virgule flottante, 4-18Nombres entiers, 4-18

Nombres à virgule flottante, 4-18ns

A la sélection de v, 5-4

OObjet utilisateur, 3-60, 3-92, 3-93, 3-95, 3-97

Assistant, 3-92En technique des composants de vue, 3-88Réutiliser, 3-60

09.99 Index


Objets de commande, 3-79OCX, 2-3, 3-54, 3-80, 3-88, 3-97

Composant de vue, 3-88Déclaration, 3-44, 3-98

ODBC, 2-2OLE, 2-2

Liaisons, 3-54Onduleur, 3-51Opérateurs, 4-29Opérations arithmétiques, 4-31Opérations sur bits, 4-34Options, 3-16, 3-44, 3-45, 3-78, 3-83Oracle, 2-4Ordinateur, 3-49

Modifier type, 3-99Paramétrages, 3-49Répertoire de, 3-47Touche de raccourci, 3-81

PPar défaut, 3-3

Déclencheur, 3-36Langue, 3-43Paramétrages, 3-3Répertoire, 3-4

Paramètres, 3-46De liaison, 3-64Diagnostic, 3-100Fermeture, 3-51Par défaut, 3-46Pour nom de projet, 3-4Pour nom de variable, 3-6Pour nom de vue, 3-7Pour printf, 4-15Pour résolution d'écran, 3-13

Performances, 3-2, 3-18, 3-39, 3-56Plate-forme, 2-2Pointeur, 3-15, 3-79, 4-39

Dans C, 4-39Police, 3-2

Couleur, 3-17Taille, 3-2, 3-13Type, 3-2

Printf, 4-15Process, 3-18

Commande, 3-11Communication, 3-23Couplage, 3-18Hiérarchie des commandes, 3-15Variables, 3-91

Programme, 3-48Démarrage automatique, 3-48Pour base de données, 3-44Programmes auxiliaires, 3-54Propres, 3-63Réutilisation de données, 3-64Utilitaires, 3-6

Projet, 3-48Bibliothèque, 3-61Conseils pour la réalisation, 3-21Copier, 3-54Créer une fonction, 4-12Démarrage automatique, 3-48Environnement, 3-45Exemple de projet, 3-3Facilité de maintenance, 3-26Fonctions, 4-11Fonctions génériques, 3-43Nom, 3-4Répertoire, 3-45Réutiliser bibliothèque, 3-60Sauvegarde, 3-53

Propriété, 3-27Dynamisation sur l'objet, 3-27En-tête de la fonction, 4-6Objet, 3-24

Propriétés d'une unité de canal, 5-63Accès à la variable distante, 5-63, 5-70Déclaration en ligne de liaisons logiques,5-63, 5-70Déclaration en ligne de variables WinCC,5-63, 5-70Ecriture sur adresse binaire, 5-63, 5-70Ecriture sur adresse d'octets, 5-63, 5-70Edition des propriétés de canal, 5-63, 5-70Fonctionnalité de client, 5-63, 5-70Horloge esclave, 5-63, 5-70Horloge maître, 5-63, 5-70Pas de déclaration de variable WinCC, 5-63,5-70Possibilités de diagnostic, 5-63, 5-70Propre affichage de redémarrage, 5-63, 5-70Propre gestion de cycles, 5-63, 5-70Propre surveillance de signes de vie, 5-63,5-70Réentrant, 5-63, 5-70Valeurs du process au format INTEL, 5-63,5-70

Protection d'accès, 3-15, 3-19, 3-50, 3-74Réutilisation des autorisations, 3-74

Prototype, 3-88, 3-89, 3-92, 3-94

QQuitter, 3-80

De WinCC, 3-51Saisie, 3-80WinCC, 3-48

RRafraîchir, 3-27

Cycles, 3-18Possibilités de paramétrage, 3-23

Index 09.99


Types de, 3-27Réalisation, 3-1Recommandation, 3-27

Pour cycles de rafraîchissement, 3-27Reconstruction, 3-44

Base de données, 3-44Recopie d'écran, 3-86Référence, 3-90

Dans des composants de vue, 3-90, 3-97Dans des vues, 3-58Référence de texte, 3-70

Règles, 3-69Lors de la réutilisation de données, 3-69

Répertoire, 3-43Bibliothèque du projet, 3-61Démarrage automatique, 3-48Données dans le répertoire WinCC, 3-43Répertoire de projet, 3-4Répertoire de projets WinCC, 3-45Structure de WinCC, 3-21, 3-42Utilitaires pour WinCC, 3-64

Requérir, 3-27Données, 3-23Données du gestionnaire de données, 3-27

Réseau, 3-52Résolution, 3-13

Ecran, 3-13Résolution d'écran, 3-13Restrictions, 3-57

Lors de la configuration en ligne, 3-99Lors de la réutilisation des données, 3-57Nom de variable, 3-6Nom de vue, 3-7

Résultat, 4-15Dynamisation, 3-41Edition, 4-15

Runtime, 3-46, 3-92, 3-97Commande dans, 3-79Conventions pour, 3-2Curseur, 3-80Données, 3-46Dynamisation, 3-38Dynamisation de, 3-38Paramétrages pour, 3-50Restrictions pour configuration en ligne, 3-99

SSaisie

Dans le champ d'E/S, 3-79Moyens, 3-15Par clavier, 3-75

Sauvegarde, 3-45, 3-51Concept de, 3-51Données WinCC, 3-52

Scope, 5-5, 5-11Accès à la base de données WinCC, 5-11

Scripts, 3-9, 3-34

Editeur de, 4-11Environnement de développement, 4-3Exécuter, 3-34Langue, 4-1Pour assistant, 3-43Syntaxe, 4-3

Sécurité transactionnelle, 2-4Sélection, 3-15, 3-29, 3-31, 3-32, 3-59, 3-81

Alarmes, 3-20Déclencheur, 3-24Des variables, 3-5Vues pour indication d'état, 3-59

Signalisation binaire, 3-20SmartTools, 3-6, 3-44, 3-54, 3-64Solution, 3-48

Démarche, 2-2Démarrage automatique de projet WinCC,3-48

Souris, 3-77Action pour touche de raccourci, 3-77Commande sans souris, 3-75Dynamisation sur événement, 3-39

Soustraction, 4-29Spécifications, 3-10SQL, 2-4, 3-49

Base de données, 3-49Programmation, 3-64Utilitaires, 3-44

ssionNormali, 5-3

Standard, 4-3C, 4-3Contenu du répertoire WinCC par défaut, 3-42Cycles, 3-27Fonctions, 3-53, 4-11Paramétrages, 3-24, 3-25Touches, 3-78

Structure, 3-7, 3-16, 3-95Base de données, 3-56Concept de commande, 3-16Etablissement de liaison, 3-100Fonctions, 4-5Formation de la vue, 3-23, 3-88Gestion des variables, 3-5Liaisons, 3-95Liste de textes, 3-67Noms de vue, 3-7Pour archivage de données, 3-21Pour création d'alarmes, 3-73Répertoire de projets WinCC, 3-45Répertoire système WinCC, 3-42Standard d'entreprise, 3-2Structure de répertoires, 3-21Variables, 3-5WinCC, 2-2

Structures, 4-65Sybase, 2-4, 3-49Symbole, 3-43

Archivage des, 3-43

09.99 Index


Exporter, 3-61Pour type de dynamisation, 3-38Réutilisations, 3-59

Syntaxe, 4-3Système, 3-48

Alarmes, 3-42Charge, 3-23, 3-28, 3-37Démarrage automatique, 3-48Logiciel, 3-54Modèle, 3-53Modules, 2-2Monoposte, 3-13, 3-56Multiposte, 3-13, 3-56Plate-forme, 2-2Système d'exploitation, 3-18Variables, 3-6, 3-58

Système de bus, 3-18Système d'exploitation, 2-2, 3-18, 3-50, 3-51

TTableau des couleurs, 5-15Tâche, 3-49

Barre des tâches, 3-49Changement de tâche, 3-27

Tâches, 3-56Equipe de projet, 3-56

Tampon cyclique, 3-15Pour vues, 3-15

Tester, 3-39Code clavier, 3-75Evénement d'un objet, 3-39

Texte, 3-11En plusieurs langues, 3-70Identification à l'écran, 3-11Liste de textes, 3-80Listes, 3-67Listes de textes, 3-63Représentation, 3-11Textlibrary, 3-100

Touche de fonction, 3-75Touche de raccourci, 3-76, 3-77, 3-81, 3-87Touches, 3-58

Affectation des touches, 3-80Combinaison de touches, 3-48Configuré, 3-70Dans la fenêtre dálarmes, 3-82Dans la fenêtre de courbes, 3-84Paramétrages des touches, 3-80Touche de raccourci, 3-77Touches de commande, 3-58Touches de fonction, 3-75Zone de boutons, 3-11, 3-17

Touches de curseur, 3-80, 3-82Transférer, 3-44

Alarmes, 3-44Variables, 3-64

UUNIX, 2-4Utilisateur, 2-3, 2-4, 3-10, 3-100

Autorisation, 3-100Autorisations, 3-19Cycles définis par l'utilisateur, 3-25Enregistrements utilisateur, 2-4Groupes, 3-19, 3-74Réutilisation des autorisations, 3-74

Utilitaires, 3-52Base de données, 3-52Graphique, 3-44Importation, exportation de variables, 3-6,3-64Langues, 3-70OCX, 3-54SQL, 3-44WinCC, 3-44

VValeur de mesure, 3-18

Archivage, 3-23Rafraîchir, 3-18Réutiliser, 3-74Saisie, 3-57Transférer, 3-44

Valeur retournée, 4-5Valeurs analogiques, 3-11

Heure, 3-97Représenter, 3-11

Variables, 3-40Dans des scripts, 3-6Déclencheur, 3-24, 3-26, 3-27, 3-36Définir, 3-5Importation, exportation, 3-52Liaison, 3-40Message d'absence de, 3-42Nom, 4-18Noms admissibles, 3-6Références dans des vues, 3-58Représentation d'informations dans des vues,3-89Réutilisation de S5 ou S7, 3-63Réutiliser, 3-63Simulation, 3-47Structure des listes exportées, 3-67Transférer, 3-64Types, 4-18Variables C, 4-17Variables d'archive, 3-85

VDE 0199, 3-17Visual, 2-2

Basic, 2-2, 3-98C++, 2-2, 3-98

Visualisation, 3-23Station, 3-23

Index 09.99


Visualiser, 2-2Vue

Construction d'une fenêtre de vue, 3-95Contenu d'une fenêtre de vue, 3-58Cycle, 3-26Hiérarchie, 3-78Informations dans la vue, 3-10Modifier cycle, 3-33Noms, 3-7Objet, 3-38Passage, 3-76Rafraîchir, 3-24Réduction du volume, 4-11Réutilisation de, 3-57Sélection, 3-15, 3-58, 3-81, 3-84, 3-97Structure, 3-23, 3-88Taille de, 3-13Technique des composants, 3-88Vue d'alarme, 3-82

Vue de process, 3-39Commande sans souris, 3-75Dynamisation, 3-39

Vues synoptiques, 3-15

WWhile, 4-47WinCC, 3-62

Actions, 3-9API, 3-63Concept de commande, 3-15Copier projet, 3-54Cycles de rafraîchissement, 3-25

Démarrage automatique, 3-48Dynamisation, 3-38Environnement de projet, 3-45Fichiers compte rendu, 3-42Gestion des variables, 3-5Interface utilisateur, 3-10Nom de projet, 3-4Paramétrages par défaut, 3-3Procédure d'alarme, 3-20Quitter, 3-51Répertoire par défaut, 3-42Réutiliser action, 3-62Réutiliser variables, 3-63Sauvegarde des données, 3-52Scripts, 3-9Structure, 2-2, 2-3Structure de répertoires, 3-45Utilitaires, 3-44, 3-54Version 1.10, 3-73

Windows, 2-2, 3-18Windows NT, 3-18

Wrebuild, 3-44Wunload, 3-44

ZZone, 3-14

Ecran, 3-11Plage de temps, 3-84Plage de valeurs, 3-39, 4-18Zone de boutons, 3-17Zone de travail, 3-14

Zone de travail, 3-14

Documents

WinCC Configuration Manual - Siemens AG · Configuration Manual Manuel tome 1 ... 3.2.10 Convention: Les procédures d'alarme ... 4.5.2 Exemple 2 – Boucle do-while