Instruction :
Vous pouvez partager la variable de 16 bits avec le script suivant, par ex. sur un bouton.

Variables	DESCRIPTIF
16Bit	Variable 16 bits à partager
8Bit_1	1ère partie de variable, destinée à stocker l'octet de poids fort de la variable de 16 bits
8Bit_2	2ème partie de variable, destinée à stocker l'octet de poids faible de la variable de 16 bits

Listing du script :

int valeur, high, low;
valeur = GetTagWord( "16Bit" );	// Acquisition de la valeur process 16 bits
high = valeur >>8;	// filtre de l'octet poids fort de la valeur process
low = 0x00ff & valeur;	// filtre de l'octet poids faible de la valeur process
SetTagByte( "8Bit_1" , high );	// sauvegarde de l'octet poids fort de la valeur process
SetTagByte( "8Bit_2" , low );	// sauvegarde de l'octet poids faible de la valeur process

Instructions
Ce script lit un nom de structure d'une variable interne "Variablenmerker" et l'utilise comme nom d'instance. La valeur de la variable est lue de la variable finale.
Le script décrit ci dessous est lancé par clic sur un bouton.

Programme :
=========

#include "apdefap.h"
void OnClick(char* lpszPictureName, char* lpszObjectName, char* lpszPropertyName)
{
char* InstanzNameA;
DWORD VarInhA;
// Préparation de la variable interne avec le nom de structure, ceci peut être déjà fait
// à un autre endroit du programme.
SetTagChar("Variablenmerker","DreieckHuellkurve");
// Réservation de la place mémoire
InstanzNameA = SysMalloc(200);
// lecture du nom de structure
strcpy(InstanzNameA,GetTagChar("Variablenmerker");
// Edition de contrôle dans la fenêtre de diagnostique
printf("Inhalt Pointer 1. Stelle: %s\r\n", InstanzNameA);
// sélectionner le nom de la variable pour le nom d'instance
strcat(InstanzNameA,".Dreieck_1");
// Edition de contrôle dans la fenêtre de diagnostique
printf("Inhalt Pointer 2. Stelle: %s\r\n", InstanzNameA);
// entrée de la valeur de la variable
VarInhA = GetTagWord(InstanzNameA);
// Edition de contrôle dans la fenêtre de diagnostique
printf("Variableninhalt: %d\r\n", VarInhA);
// libération de la mémoire réservée
SysFree(InstanzNameA);
}
 

Vous utilisez dans votre projet une liaison FMS de WINCC vers un automate. Vous voulez adresser des bits individuellement dans l'automate par cette liaison. Le canal FMS ne gère pas de transfert de Byte ou de Bit. Donc vous ne pouvez adresser des bits individuellement qu'à l'intérieur de mots ou de double-mots. Pour cela vous avez deux possibilités :

Dynamic Wizard
Dans le DynamicWizard de l'éditeur graphique (Graphics Designer) de WinCC, vous pouvez sélectionner la fonction "Mise à un/ zéro d'un Bit" sous l'onglet " Dynamiques Standard ".
Vous pouvez configurer cette action derrière un objet dans l'éditeur graphique. Dans la boite de dialogue, vous pouvez sélectionner le déclenchement, la variable, l'action (mise à un/zéro) et le bit que vous voulez modifier.

Fig. 01

Fonctions de Projet
Utiliser les fonctions de projet ci-dessous, décrivant les bits individuels d'une variable de process FMS (16-bit ou 23-bit).
 

Application dans une action :

1. Créez une variable 16 bits ou 32 bits dans la liste des variables de WinCC sous le pilote de liaison FMS. Le bit que vous voulez adresser est un bit de cette variable.
2. Incorporez la fonction désirée dans votre projet :
   Copiez le fichier Funktionen.zip dans un fichier séparé et lancez le par un double clic. Copiez les fichiers ainsi décompactés dans le répertoire HD:\ProjectName\Library\. Ouvrez l'éditeur GlobalScripts et générez à nouveau l'en-tête. Maintenant les fonctions copiées apparaissent sous les fonctions du projet. Vous trouvez ci-dessous la description détaillée de cette fonction.

   

3. Insérez un objet avec lequel le bit doit être mis à un ou à zéro par un clic. Ouvrez la propriété de l'objet. Passez dans l'onglet "Événement". Choisissez "Souris" et effectuez un double clic sur "Clic de souris". Il s'ouvre une fenêtre dans laquelle vous pouvez éditer l'action.

   

4. Sélectionnez dans la fenêtre action par un double-clic, une des fonctions de votre projet qui ont été précédemment insérées.
5. Indiquez une variable que vous avez configurée comme premier paramètre au point 1. Vous pouvez la sélectionner dans la liste de variables.
6. En deuxième paramètre indiquez le bit qui doit être mis à un ou à zéro.

   

7. Cliquez sur "OK". Maintenant le script est généré.
8. Cliquez encore une fois sur "OK", pour compiler l'action et la mémoriser. Maintenant le bit peut être mis à un ou à zéro par un clic sur cet objet.

Visualisation par un champ E/S

Pour un contrôle visuel de la variable créez un champ d'E/S dans GraphicsDesigner :

1. Créez une variable 16-bits ou 32-bits de la liste variable de WinCC sous la liaison FMS. Le bit que vous voulez adresser fait partie de cette variable.
2. Dans Graphics Designer, installez maintenant un champ E/S. Sélectionnez dans propriété comme type de champ "Sortie", comme format de données "Binaire" et comme format de sortie "1".

   

3. Indiquez dans les seuils, comme seuil inférieur "0" et comme seuil supérieur "1".

   

4. Ouvrez le dialogue dynamique dans propriété de valeur de sortie. Comme type de données choisissez "Bit". La variable est celle que vous avez définie sous le point 1. Choisissez le bit que vous voulez adresser. Sous "Résultat de l'expression / la formule" positionnez pour la sortie "1" pour "activé" et "0" pour "désactivé".

   

5. Cliquez sur le bouton "Valider" pour terminer la configuration du champ d'E/S. Maintenant le champ d'E/S représente l'état du Bit de l'automate.

DESCRIPTIF des fonctions attachées

ResetWordTagBit

Cette fonction remet à zéro le bit sélectionné dans la variable
Paramètre
TagName	Variable 16Bits contenant le bit, qui doit être remis à zéro
Bit	Le bit dans la variable, qui doit être remis à zéro

ResetDWordTagBit

Cette fonction remet à zéro le bit sélectionné dans la variable
Paramètre
TagName	Variable 32Bits contenant le bit, qui doit être remis à zéro
Bit	Le bit dans la variable, qui doit être remis à zéro

SetWordTagBit

Cette fonction met à un le bit sélectionné dans la variable
Paramètre
TagName	Variable 16Bits contenant le bit qui doit être mis à un
Bit	Le bit dans la variable, qui doit être mis à un

SetDWordTagBit

Cette fonction met à un le bit sélectionné dans la variable
Paramètre
TagName	Variable 32Bits contenant le bit qui doit être mis à un
Bit	Le bit dans la variable, qui doit être mis à un

Téléchargement des fonctions du projet :
Functions.zip ( 4 KB )

Listing des fonctions du projet :
Functions.pdf ( 6 KB )

QUESTION:
Je souhaite convertir un nombre entier en ASCII avec un script WinCC. Comment dois-je procéder ?

REPONSE:
Utilisez la routine String I/O "sprintf()".

Vous trouverez, ci-joint, un projet WinCC qui vous montre cette conversion. Dans le gestionnaire de variable de WinCC, deux variables internes ont été créées avec les propriétés suivantes :
 

Nom	Type de données
inint	Valeur 32 bits signée
outstr	Variable de type texte 16 bits

Lorsque vous démarrez le Runtime, la fenêtre suivante apparaît :

Dans le champ "input integer", vous indiquez la valeur entière et vous cliquez ensuite sur le bouton "convert". Dans le champ "output string", apparaît alors la valeur entière sous la forme d'une chaîne. Le script en C qui se trouve derrière le bouton "convert" et permettant de convertir un entier en une chaîne de caractères ressemble à :

DWORD Val;
char TmpStr[64];

Val = GetTagDWord("inint");
sprintf (TmpStr, "%u", Val);
SetTagChar ("outstr", TmpStr);
printf("\"%s\"\r\n",TmpStr);

Le projet WinCC se trouve dans l'archive zip ci-jointe. Le projet a été créé avec WinCC V5.0. Copiez le fichier sur votre disque dure et décompactez l'archive par un double-clic.

int2str_1.exe ( 1833 KB )

Description
Une variable texte 8-Bit est liée à un champ d'E/S dans WinCC. La valeur associée dans l'AS doit être affichée comme tel dans AlarmLogging-Control et envoyée avec le SFB35. Cette variable texte configurée par l'utilisateur est écrite dans l'AS comme une chaîne S7 "S7 String". Cependant, ce type de données a un en-tête de 2 octets qui n'est pas affiché.

Les valeurs associées à un message ne sont pas de type "S7 String", mais des tableaux de type CHAR. L'AS envoie alors les données comme valeur additionnelle à partir d'une adresse de départ. Si cette adresse est mise au début de la variable texte mentionnée ci-dessus, le texte comprenant l'en-tête est affiché dans AlarmLogging-Control. Afin d'éviter ceci, vous devez augmenter l'adresse de début de 2 octets.

Exemple
Dans le gestionnaire de variables, la variable String "varOtto" est configurée avec l'adresse DB10.DBB16. Si vous écrivez le texte "anna" dans la variable, on trouvera dans l'AS à l'adresse DB10.DBB16 : "0A 04 a n n a". Si vous assignez le paramètre SD_n : = P#DB10.DBX16.0 CHAR 4, quand un message arrive, il transfère l'en-tête et les deux caractères suivants, dans ce cas-ci donc : "0A 04 a n". Afin d'afficher la valeur associée correctement, vous devez placer le paramètre suivant : SD_n : = P#DB10.DBX18.0 CHAR 4.

Fig 1: Variable "varOtto" dans le gestionnaire de variables de WinCC, dans un bloc de données Step 7 et dans une table de variables ( 244 KB )  

Mots Clés
Configuration de messages, valeurs d'accompagnement

Instructions
Vous utilisez dans votre script la fonction interneGetTag ou SetTag. Dans la fonction vous accédez à des variables, qui ne sont utilisées par aucun objet dans l'image. Le premier accès sur la variable dure véritablement plus longtemps que les accès suivants.

Cause
Avant de pouvoir accéder sur une variable, elle doit être réclamée au manager de données de pour être mise en actualisation.
Si des objets sont dynamisés dans des images process avec des variables, le Graphics Runtime connaît quelles sont les variables qui sont nécessaires pour une image process. Ainsi toutes les variables utilisées sont déjà prêtes pour l'actualisation lors de la demande par l'image.
Si une variable n'est pas utilisée dans l'image et que vous y accédez dans un script, la variable ne sera pas encore disponible. La variable doit d'abord être déclarée pour être actualisée. Par conséquent le premier accès dure toujours plus longtemps.

Remède

• Installez des objets invisibles dans l'image.
• Dynamisez les propriétés de cet objet avec les variables qui sont utilisées dans le script.
  Exemple :
  Insérez un champ de texte et dynamisez les couleurs avec chaque fois une des variables du script.

Cela aura pour conséquence, que toutes les variables nécessaires au script seront alors déjà mises à disposition lors de l'appel de l'image. Et ainsi les premiers appels des fonctions GetTag ou SetTag seront aussi rapides que les appels suivants.

Mots-clefs
Réduction des temps, demande de variables

Description
Toutes les opérations possibles en C sont autorisées. Le tableau suivant indique quelques exemples.
 

Opérateurs logiques	Fonction
= =	Test d’égalité
! =	Test d'’inégalité
&&	ET logique entre 2 conditions
||	OU logique entre 2 conditions
!	Négation

Table de vérité:
 

Condition 1	Condition 2	! (de la condition 1)	= =	! =	&&	||
0	0	1	1	0	0	0
0	1	1	0	1	0	1
1	0	0	0	1	0	1
1	1	0	1	0	1	1

Information
Veuillez noter que les opérateurs "&" et "|" travaillent en mode binaire et que l’opérateur "=" implique une affectation.
Vous trouverez des informations complémentaires pour la création de scripts en C dans le manuel "WinCC Scripting" ou dans un manuel technique de programmation C.

Instruction :  
La mémoire nécessaire est réservée pour l’utilisation de Strings avec la fonction GetTagMultiWait via SysMalloc.
La mémoire réservée avec SysMalloc  est utilisée pour stocker les Strings.
Les adresses initiales de chaque Strings sont retournées vers la fonction d’appel (e.g. le script utilisateur).

Le paramètre d’appel pour les Strings doit avoir le format suivant:

·"font:7.0pt "Times New Roman"">         Pour GetTagMultiWait

Stringformat	s
WinCC-Variable	Nom de la variable texte WinCC
C-Variable	Référence à un pointeur format Char ( i.e. l’adresse du pointeur )

·"font:7.0pt "Times New Roman"">         Pour SetTagMultiWait:

Stringformat	s
WinCC-Variable	Nom de la variable texte WinCC
C-Variable	Pointeur type char ( adresse initiale du String )

Exemple pour copier des valeurs :

char* string;                                              // pointeur sur string
char* string_array[2];                                //2 pointeurs sur strings

GetTagMultiWait("%s%s%s", 
"textvariable_8bit_1",     &string,
"textvariable_8bit_2",     &string_array[0],
"textvariable_8bit_3",     &string_array[1]);

SetTagMultiWait("%s%s%s",
"textvariable_8bit_4",     string,
"textvariable_8bit_5",     string_array[0],
"textvariable_8bit_6",     string_array[1]);

Remarques de configuration:
Lors d'opérations bit par bit sur une ou plusieurs variables 32 bits dans WinCC Global Script / VBScript, il peut se produire un dépassement provoquant l'annulation du script si le bit de poids fort ( Bit31 ) est à 1 dans une des variables.

Exemple:
Si VBScript est utilisé pour afficher l'état de bits particuliers de double mot dans une image, alors l'affichage est incorrect si le bit 31 est mis à 1 dans le double mot.

Remède:
Assurez vous que le Bit31 d'une variable double mot n'est pas utilisé/affecté quand vous réalisez des opérations bit sur bit (ex. opérateur "And").  Vous devez vérifier l'état du bit de poids fort d'une variable 32 bits avant de réaliser la première opération bit sur bit et si nécessaire, modifiez cet état. En utilisant la requête "supérieur ou égal à", vous pouvez déterminer si le bit 31 d'une variable32 bits est à 1. Si la valeur d'une variable 32 bits est supérieure ou égale à 2³¹ alors le bit 31 est à 1. Dans ce cas, vous pouvez soustraire la valeur 2³¹ de la valeur de la variable 32 bits pour remettre à 0 le bit 31. Par ce moyen, les autres bits sont évalués correctement. L'image suivante montre un script VBScript qui clarifie la procédure. Dans cet exemple, l'état du bit 0 de la variable 32 bits est utilisé pour la dynamisation. Si le bit 0 est à 1, la couleur d'arrière plan d'un objet est verte, sinon elle est grise.

Image 01 

Le script VBScript suivant utilise la méthode décrite ci-dessus pour transférer la valeur des bits d'une variable 32 bits et l'affecter dans un champ bit. Ensuite, dans le champ bit, vous pouvez correctement appeler et travailler sur les bits séparés.

WinCC_VBOverflowBit31_vbs.pdf ( 9 KB )

Le téléchargement suivant présente le script sous forme d'un fichier texte.

WinCC_VBOverflowBit31.zip ( 6 KB )

Mots clés:
VBS, Visual Basic Script, Bit-31, Bit-32, MSB

Instructions:
Dans WinCC Global Script C vous disposez en standard de différentes fonctions "SetTagMultiWait()"-pour écrire plusieurs variables WinCC:

• BOOL SetTagMultiWait(const char* pszFormat, const char* pszTag, void vValue, ...)
• BOOL SetTagMultiStateWait(DWORD* pdwState, const char* pszFormat, const* pszTag, void vValue, ...)

Ces fonctions sont des fonctions "Wait" donc en lecture synchrone, c'est à dire que les valeurs des variables sont lues directement dans l'automate et non dans le WinCC-Datamanager. Le nombre de paramètres de ces fonctions est variable et dépendant du nombre de variables à écrire.

Paramètre:
Les fonctions "SetTagMulti()"-utilisent les paramètres suivants:

• DWORD* pdwState (uniquement avec SetTagMultiStateWait())
  L'utilisateur de la fonction "SetTagMulti()"doit prévoir un champ pour une variable DWORD (réserver mémoire). La fonction "SetTagMulti()"retourne un pointeur sur le premier élément du champ. La fonction "SetTagMulti()"écrit à l'adresse de la variable qui est écrite.
   
• const char* pszFormat
  L'utilisateur de la fonction "SetTagMulti()"doit prévoir une chaîne de caractères (réserver mémoire) et initialiser avec l'information du format pour les variables WinCC écrites. La fonction SetTagMulti()-retourne un pointeur sur le premier élément de la chaîne de caractères.
   
• const char* pszTag
  "pszTag" est un pointeur sur le premier élément de la chaîne de caractères qui contient le nom de la variable WinCC lue.
  L'utilisateur de la fonction "SetTagMulti()"doit transmettre pour chaque variable écrite une chaîne de caractères "pszTag".
   
• void vValue
  "vValue" est la valeur est écrite dans la variable WinCC.
  L'utilisateur de la fonction "SetTagMulti()"doit transmettre pour chaque variable écrite ces paramètres.
  Les types de données peuvent varier en fonction du type de données des variables WinCC écrites. Les types de données possibles sont présentés dans le tableau ci-dessous.

Valeur de retour:
La fonction "SetTagMulti()"retourne la valeur "TRUE" quand la fonction s'est exécutée correctement. Si une erreur survient lors de l'exécution du programme, par exemple au moins un paramètre transmet la valeur NULL ou le format de la chaîne de caractères contient un formatage incorrect, la valeur de retour est "FALSE". La fonction ne vérifie pas si la variable est écrite sans erreur. Pour cette raison la valeur de retour ne peut pas être utilisée pour vérifier si l'écriture des variables WinCC s'est bien déroulée ou pas. Utilisez pour cela la fonction "SetTagMultiStateWait()" et la variable d'état pour l'analyse d'erreur.

Vous trouverez des informations sur la qualité des variables WinCC (état des variables) dans l'aide en ligne WinCC Information System sous:

• "communication > Diagnostic de la communication > Qualité des variables > État des variables"

Vous trouverez des informations générales sur le fonctionnement des fonctions "SetTag()" dans WinCC Information System sous:

• "Travailler avec WinCC > Créer des fonctions et actions en ANSI-C > Description de fonctions ANSI-C > Fonctions Internes > tag > set > Fonctionnement des fonctions GetTag"

Le tableau suivant décrit les formatages possibles dans une chaîne de caractères et donne des indications sur les types de formatage à utiliser en fonction des types de données pour variables WinCC ou variablesC.
 

Format	type de données WinCC	Type de données C
"%d"	tous types de variables WinCC Bit 8-Bit non signée 8-Bit signée 16-Bit non signée 16-Bit signée 32-Bit non signée 32-Bit signée	32-Bit Variable (4 Byte) Le formatage "%d" est utilisé pour écrire une valeur dans une variable WinCC entier. Pour une variable C il est nécessaire de réserver toujours quatre octets indépendamment de la taille de la variable WinCC car sinon la fonction "SetTagMulti()" écrit une fausse valeur de retour dans la variable WinCC. L'article 26710239 décrit comment déterminer la taille de la mémoire nécessaire pour une variable C. Les types de données possibles sont par exemple.: BOOL, DWORD, int, long Exemple: Pour écrire la valeur d'une variable WinCC 8 bits signée, vous pouvez utiliser une variable C du type de données  "DWORD" et la fonction "SetTagMulti()". Pour écrire la valeur dans une variable WinCC 8 bits non signée, vous pouvez utiliser une variable C du type de données "int" ou "long" et la fonction "SetTagMulti()". Attention! Lors de l'utilisation d'une variable WinCC du type de données "32 bits signée" (DWORD) il n'est pas autorisé d'utiliser le bit de poids fort (Bit 31), car la fonction SetTagMulti() n'écrit pas la valeur souhaitée dans la variable . Dans la variable d'état une erreur est affichée
"%f"	Variables décimales décimales 32-Bit IEEE 754 décimales 64-Bit IEEE 754	"double" ou "float" Le formatage "%f" est utilisé pour écrire une valeur dans une variable décimale WinCC. Pour une variable C, les variables "float" ou "double"sont utilisées. Exemple: Pour écrire une valeur dans une variable décimale 32-Bit , vous pouvez utiliser une variable C avec le type "double" ou "float" et la fonction "SetTagMulti()". Remarque: Si les fonctions "GetTagMulti()" et "SetTagMulti()" sont utilisées par exemple pour lire, modifier ou de nouveau écrire, alors il peut être pertinent d'utiliser le type "double" pour une variable décimale car la fonction "GetTagMulti()" ne peut être utilisée que pour le type "double".
"%s"	Variables Text Texte 8-Bit Texte 16-Bit	"char*"-Variable (pointeur sur un caractère) Le formatage "%s" est utilisé pour écrire une valeur dans une variable texte WinCC. L'utilisateur doit réserver la mémoire nécessaire pour la chaîne de caractères en C. La fonction SetTagMulti() retourne l'adresse sur le premier élément sur la chaîne de caractères.

Comportement sur erreur:
Vous trouverez ci-dessous le comportement en cas d'erreur :

• Accès à une variable WinCC inexistante
  Si vous accédez à des variables inexistantes avec les fonctions "SetTagMultiWait()" ou "SetTagMultiStateWait()", une erreur "OnErrorExecute" est générée dans la fenêtre de diagnostic Global Script ou dans "APDIAG Output Window"  ("Tag unknown, timeout or conversation failed - Tag not found"). L'état de la variable contient l'information sur l'erreur d'accès.
   
• Utilisation d'un type de données C avec moins de 4 octets de mémoire pour écrire une variable WinCC
  En utilisant une variable C avec moins de quatre octets de réservation mémoire (ex. BYTE, WORD, char ou short), pour écrire le contenu d'une variable WinCC, il est fortement probable d'écrire une valeur erronée dans la variable WinCC car la fonction écrit toujours quatre octets. L'état de la variable indique une erreur ("dépassement de format").
   
• Accès à une variable 32 bits signée dans laquelle le bit de poids fort (Bit 31) est utilisé
  Si on doit écrire le contenu d'une variable C du type "DWORD" dans une variable WinCC du type 32 bits signée ("DWORD") et que le Bit 31 est affecté, alors la valeur ne sera pas écrite dans la variable WinCC par la fonction  "SetTagMulti()". Aucune erreur "OnErrorExecute" ne sera générée dans la fenêtre de diagnostic Global Script ou "APDIAG Output Window" . L'état de la variable contient les informations sur l'erreur générée ("dépassement de limites").
  Remèdes:
  • Assurez vous (quand c'est possible) que le Bit 31 d'une variable 32 bits signée n'est pas utilisé.
  • Si la variable WinCC est une variable externe, il est possible de définir une limite supérieure 2147483648 (Hexadezimal 0x80000000) pour cette variable.
    
    
    Image 01
     
    
    Le code qualité et l'état de la variable donne des indications sur le dépassement de la limite supérieure.
     
  • Utiliser la fonction "SetTagDWordXXX()".
  • définir la variable WinCC comme variable non signée et utiliser le type "DWORD" pour la variable C.
     
• Erreur dans la structure du format de la chaîne de caractères
  • le formatage est incompatible avec les types de données
    Ci-dessous, quelques cas dans lesquels les formatages sont invalides et le retour de la fonction est "FALSE":
    • Le formatage "%s" ou "%f" est utilisé pour écrire une variable numérique.
    • La formatage "%s" ou "%d" est utilisé pour écrire un décimal.
    • Le formatage "%f" est utilisé pour écrire une variable texte.
    Ci-dessous, un cas est décrit dans lequel le formatage est invalide et la fonction retourne la valeur "TRUE". La valeur écrite est incorrecte. Dans ce cas, l'état de variable ne contient pas d'informations sur l'erreur.
    • Le formatage "%d" est utilisé pour écrire une variable Texte.
       
  • Le format de la chaîne contient trop de paramètres de formatage
    Si tous les paramètres correspondant à la chaîne de formatage (pszTag, vValue) l'exécution de la fonction "SetTagMulti()" génère une erreur "OnErrorExecute"dans une fenêtre de diagnostic Global Script ou "APDIAG Output Window"  ("Tag unknown, timeout or conversation failed - Tag not found"). L'état de variable contient des informations sur l'erreur.
    
    Remarque:
    Si il y a plus de paramètres (pszTag, vValue) que dans la chaîne de caractères, alors l'écriture s'effectuera correctement. Les valeurs qui ne sont pas associées au caractère de formatage ne seront pas écrits. L'état de variable pour ces variables contiennent les informations sur l'erreur. Aucune erreur n'est générée dans la fenêtre de diagnostic de Global Script Diagnosefenster ou "APDIAG Output Window".

Exemple de configuration: construction dynamique de la chaîne de formatage
Si beaucoup de variables doivent être écrites avec la fonction SetTagMulti(), la construction de la syntaxe peut s'avérer délicate. Il n'est pas aisé de détecter des erreurs de syntaxe de la chaîne de caractères directement à l'oeil. Pour éviter les erreurs dans la construction de la chaîne de caractères, il est possible de créer la chaîne de formatage en dynamique. Les informations sur les variables qui doivent être écrites avec la fonction SetTagMulti() peuvent être définis dans un champ dans lequel chaque élément représente une structure contenant les informations nécessaires (formatage, nom de variable WinCC et  variable C).

La procédure est illustrée dans le script disponible en téléchargement ci-dessous (PDF- et fichier texte).

WinCC_SetTagMulti_c.zip ( 7 KB )

WinCC_SetTagMulti_c.pdf ( 10 KB )

Les deux images suivantes montrent les variables internes et externes qui sont écrites avec la fonction "SetTagMultiStateWait()".

Image 02
 

Image 03
 

Le script peut être appelé dans une action C dans une vue (ex. événement clic souris sur un bouton).
La vue suivante montre le contenu de la variable WinCC en Runtime. Les variables WinCC sont affichées dans la vue par une liaison directe sur variable sur des champs d'entrée sortie sur la propriété "OutputValue". En même temps la fenêtre de sortie de l'outil "APDIAG" affiche les valeurs écrites.

Image 04
 

Remarque:
Le script a été créé avec WinCC V6.2.

Instructions:
Dans WinCC Global Script C vous disposez en standard de différentes fonctions "GetTagMultiWait()"-pour lire plusieurs variables WinCC:

• BOOL GetTagMultiWait(const char* pszFormat, const char* pszTag, void* pvValue, ...)
• BOOL GetTagMultiStateWait(DWORD* pdwState, const char* pszFormat, const* pszTag, void* pvValue, ...)
• BOOL GetTagMultiStateQCWait(DWORD* pdwState, DWORD* pdwQC, const char* pszFormat, const* pszTag, void* pvValue, ...)

Ces fonctions sont des fonctions "Wait" donc en lecture synchrone, c'est à dire que les valeurs des variables sont lues directement dans l'automate et non dans le WinCC-Datamanager. Le nombre de paramètres de ces fonctions est variable et dépendant du nombre de variables à lire.

Paramètre:
Les fonctions utilisent les paramètres suivants :

• DWORD* pdwState (uniquement avec GetTagMultiStateWait() et GetTagMultiStateQCWait())
  L'utilisateur de la fonction "GetTagMulti()"-doit prévoir un champ pour une variable DWORD (réserver mémoire). La fonction "GetTagMulti()" transmet le pointeur sur le premier élément du champ. La fonction "GetTagMulti()"-écrit à l'adresse l'état des variables qui sont lues.
• DWORD* pdwQC (uniquement avec GetTagMultiStateQCWait())
  L'utilisateur de la fonction "GetTagMulti()"-doit prévoir un champ pour une variable DWORD (réserver mémoire). La fonction GetTagMulti()-transmet le pointeur sur le premier élément du champ. La fonction "GetTagMulti()"-écrit à le code qualité des variables qui sont lues.
• const char* pszFormat
  L'utilisateur de la fonction "GetTagMulti()"doit prévoir une chaîne de caractères (réserver mémoire) et l'initialiser avec les informations de format pour les variables WinCC lues. La fonction GetTagMulti()-transmet le pointeur sur le premier élément de la chaîne de caractères.  
• const char* pszTag
  "pszTag" est un pointeur sur le premier élément de la chaîne de caractères qui contient le nom d'une des variables WinCC lues.
  L'utilisateur de la fonction "GetTagMulti()" doit fournir pour chaque variable lue une chaîne de caractères "pszTag".
• void* pvValue
  "pvValue" est une adresse à laquelle la fonction "GetTagMulti()" retourne la valeur de la variable WinCC lue.
  L'utilisateur de la fonction "GetTagMulti()"doit transmettre une adresse pour chaque variable lue.

Valeur de retour:
La fonction "GetTagMulti()" retourne la valeur "FALSE" quand au moins un paramètre a la valeur "NULL" sinon retourne la valeur "TRUE". Pour cette raison, la valeur de retour ne peut pas être utilisée pour vérifier si la lecture s'est bien passée ou pas. C'est pourquoi vous devez utiliser les fonctions "GetTagMultiStateWait()" ou "GetTagMultiStateQCWait()" et utilisez l'état de la variable ou le code qualité pour analyser les erreurs.

Vous trouverez des informations sur la qualité des variables WinCC (état variables et code qualité) dans WinCC Information System sous:

• "Communication > Diagnostic de la communication > Qualité de variables > État de variables"
• "Communication > Diagnostic de la communication > Qualité de variables > Codes qualité de variables"

Vous trouverez des informations générales sur le fonctionnement des fonctions "GetTag()" et des exemples simples dans WinCC Information System sous:

• "Travailler avec WinCC > ANSI-C pour créer des fonctions et des actions > ANSI-C Description de fonctions > Fonctions internes > tag > get > Fonctionnement de la fonction GetTag"

Le tableau suivant décrit les formats possibles pour les formats de chaînes de caractères et donne des indications sur quels formatage doit être utilisé avec les variables WinCC et les types de données C.
 

Format	WinCC-type de données	C-type de données
"%d"	toutes Variables Bit 8 bits non signés 8 bits signés 16 bits non signés 16 bits signés 32 bits non signés 32 bits signés	32-Bit Variable (4 Byte) Le formatage "%d" est utilisé pour écrire la valeur d'une variable WinCC dans une variable C. Pour les variables C, il faut toujours définir une taille mémoire de 4 octets quelque soit le type de la variable car la fonction GetTagMulti()-lors de l'utilisation du formatage "%d" écrit toujours 32 Bit (4 Byte) à l'adresse de destination. L'article 26710239 décrit comment définir la taille nécessaire pour une variable C. Les types de données possibles par exemple.: BOOL, DWORD, int, long Exemple: Pour lire une variable 8 bits signés, vous pouvez créer une variable C de type DWORD et la fonction "GetTagMulti()"-retourne l'adresse de cette variable. Pour lire une variable 8 bits non signés, vous pouvez créer une variable C de type int ou long et la fonction "GetTagMulti()"-retourne l'adresse de cette variable. Attention! Lors de l'utilisation d'une variable WinCC du type "32 bits signés" (DWORD) il ne faut pas utiliser le bit de poids fort (Bit 31), car la fonction GetTagMulti() retourne dans ce cas une erreur de conversion et la valeur 0.
"%f"	variables décimales variables décimales 32-Bit IEEE 754 variables décimales 64-Bit IEEE 754	"double"-Variable Le formatage "%f" est utilisé pour écrire la valeur d'une variable décimale dans une variable C. Pour les variables C, il faut réserver une taille mémoire de 8 octets car la fonction GetTagMulti()-écrit toujours 64 bits lors de l'utilisation du formatage "%f" à l'adresse de destination. Utilisez le type "double". Exemple: Pour lire la valeur d'une variable WinCC décimales 32-Bit, vous devez utiliser une variable C avec le type double et la fonction "GetTagMulti()"-retourne l'adresse à cette variable.
"%s"	variables Texte Texte 8 bits Texte 16 bits Texte de référence	"char*"-Variable (pointeur sur un caractère) Le formatage "%s" est utilisé pour écrire la valeur d'une variable texte ou d'un texte de référence dans une variable C. L'utilisateur doit réserver la mémoire pour le pointeur sur une chaîne de caractères. La fonction GetTagMulti()-retourne l'adresse à ce pointeur. La fonction GetTagMulti()-réserve la mémoire nécessaire pour enregistrer le contenu de la variable Texte WinCC, place le contenu de la variable Texte WinCC dans la mémoire réservée et écrit l'adresse de la mémoire réservée à l'adresse transmise. Exemple: Pour lire la valeur d'une variable Texte WinCC, vous devez définir une variable C du type pointeur sur une chaîne de caractères "char*"(pointeur) et la fonction "GetTagMulti()"retourne l'adresse à cette variable. (...oh, un pointeur sur un pointeur!)

Comportement en cas d'erreurs de configuration:
Ci-dessous est décrit le comportement dans quelques cas d'erreurs de développement:

• Accès à une variable WinCC qui n'existe pas
  Si on tente d'accéder à une variable inexistante avec les fonctions "GetTagMultiStateWait()" ou "GetTagMultiStateQCWait()", une erreur "OnErrorExecute" ("Tag unknown, timeout or conversation failed - Tag not found")est affichée soit dans une fenêtre de diagnostic Global Script soit dans une fenêtre Output "APDIAG. La variable d'état et le code qualité contiennent l'information pour analyser l'erreur.
  
  Attention!
  La fonction "GetTagMultiWait()" ne génère pas d'erreur "OnErrorExecute" dans ce cas.
   
• Utilisation du type de données "float"pour lire une variable décimale
  Pour écrire le contenu d'une variable WinCC du type décimale 32 bits IEEE 754" dans une variable C du type "float", la fonction "GetTagMulti()"retourne la valeur "0.0" comme valeur décimale. Aucune erreur n'est signalée dans la fenêtre de diagnostic Global Script ou par  "APDIAG Output Window". La variable d'état et le code qualité ne donnent pas d'informations sur une erreur d'accès.
   
• Utilisation d'un type de données C avec moins de 4 octets de mémoire pour lire un nombre entier WinCC
  Si une variable C utilise moins de 4 octets de mémoire (ex. BYTE, WORD, char ou short), pour lire le contenu d'un nombre entier WinCC, cela peut conduire à un comportement indéfini du système ou de l'installation car la fonction GetTagMulti() écrit dans ce cas une zone mémoire indésirable.
   
• Accès à une valeur WinCC 32-Bit signés dans laquelle le bit de poids fort est utilisé (Bit 31)
  Pour écrire le contenu d'une variable WinCC du type 32 bits signés ("DWORD") dans une variable C du type "DWORD", la fonction "GetTagMulti()"retourne la valeur "0" (Hexadezimal 0x00000000) comme entier. Dans une fenêtre de diagnostic de Global Script ou "APDIAG Output Window" une erreur "OnErrorExecute"est générée ("Tag unknown, timeout or conversation failed - OLE conversation failed"). La variable d'état et le code qualité ne contiennent pourtant pas d'informations sur l'erreur d'accès.
  
  Solution:
  • Assurez vous que le bit 31 de la variable 32 bits signés ne soit jamais utilisé.
  • Si vous utilisez une variable WinCC  32-Bits est une variable externe WinCC alors vous pouvez configurer dans le WinCC Datamanager une limite supérieure2147483648 (Hexadezimal 0x80000000) pour cette variable.
    
    
    Image 01
    
    
    La violation de la limite supérieure configurée est indiquée par le code qualité et l'état de la variable et peut être modifiée ultérieurement.
     
  • Utiliser la fonction "GetTagDWordXXX()".
  • Créer une variable WinCC 32 bits signés dans le gestionnaire de variables et utiliser le type de données "DWORD" pour la variable C.
     
• Erreur de création du format de chaîne de caractères
  • Le formatage est incorrect en fonction des types de données utilisés incorrects
    Si le format de la chaîne de caractères est utilisé pour un certain type de données non autorisé, alors la valeur retournée est invalide. Dans la fenêtre de diagnostic Global Script ou "APDIAG Output Window" alors une erreur "OnErrorExecute" est générée ("Tag unknown, timeout or conversation failed - OLE conversation failed"). La variable d'état et le code qualité ne contiennent  pas d'informations sur l'erreur d'accès.
    
    Exemple:
    Cette erreur apparaît quand une variable Texte WinCC est lue avec le formatage "%d".
     
  • La chaîne de formatage contient trop de paramètres de formatage
    Si tous les paramètres nécessaires ne sont pas transmis pour toutes les chaînes de formatage dans le format de la chaîne de caractères (pszTag, pvValue) la fonction "GetTagMulti()" retourne une erreur "OnErrorExecute" qui apparaît dans la fenêtre de diagnostic Global Script ou "APDIAG Output Window" ("Tag unknown, timeout or conversation failed - Tag not found"). La variable d'état et le code qualité contiennent des informations sur l'erreur qui a été générée.
    
    Solution:
    Définir plus de paramètres que dans la chaîne de formatage (pszTag, pvValue) pour que la valeur demandée par le formatage de la chaîne de caractères soit correcte. Les valeurs pour lesquelles aucun formatage n'est présent dans la chaîne de caractères ne sont pas récupérées. La variable d'état et le code qualité pour ces variables contiennent des informations sur l'erreur survenue. Aucune erreur "OnErrorExecute" n'est signalée dans la fenêtre de diagnostic Global Script ou "APDIAG Output Window".

Exemple de configuration: Construction dynamique du format de la chaîne de caractères
Si beaucoup de variables doivent être lues avec la fonction GetTagMulti(), alors la construction de la chaîne de caractères du formatage peut être délicate. Il n'est pas aisé de déterminer rapidement d'un coup d'oeil si le nombre de paramètres est suffisant ou si le format est correct. Pour éviter de faire des erreurs dans la construction de la chaîne de caractères du formatage, il est possible de construire dynamiquement la chaîne de caractères du formatage. Vous pouvez placer les informations (format, nom de variable, adresse de destination) sur les variables à lire avec la fonction GetTagMulti() dans un objet.

Un script est disponible ci-dessous pour le téléchargement (PDF- et fichier texte) qui démontre la procédure.

WinCC_GetTagMulti_c.zip ( 1 KB )

 WinCC_GetTagMulti_c.pdf ( 10 KB )

Les 2 images suivantes montrent les variables WinCC internes et externes dans le gestionnaire de variables qui doivent être lues avec la fonction"GetTagMultiStateQCWait()" .

Image 02
 

Image 03
 

Le script peut être appelé dans un script en C dans une vue (ex. événement clic souris sur un bouton).
L'image suivante montre le contenu des variables WinCC en Runtime. Les variables WinCC sont affichées dans la vue par une liaison directe sur la propriété "OutputValue" d'une champ d'Entrée/sortie. Simultanément les valeurs lues sont affichées dans une fenêtre de sortie de l'outil de diagnostic "APDIAG".

Image 04

Remarque:
Le script a été créé avec WinCC V6.2.

Description :
Ce comportement est dû à la propriété de la fenêtre de vue "préfixe de variable", vous trouverez des informations à ce sujet dans l'aide en ligne de WinCC  "WinCC Information System > Travailler avec WinCC > VBS pour la création de procédures et d'actions > Référence VBS > Propriétés > T > Propriété TagPrefix" .

Le préfixe de variable est associé à toutes les variables qui se trouvent dans l'objet fenêtre de vue. Si le préfixe de variables est utilisé lors de la liaison avec la variable et avec la propriété "préfixe de variable" de la fenêtre de vue, le nom de la variable contient alors les deux préfixes. Une erreur d'accès se produit alors lors de l'accès à ces variables.

Un exemple d'utilisation de "préfixe de variable" est disponible à l'article 23690358 .

Instructions
En utilisant le script ci-dessous, vous pouvez basculer la valeur de la variable de type de données "Binaire" (toggle) :

If HMIRuntime.Tags("BinaryTag1").Read = 0 Then
   HMIRuntime.Tags("BinaryTag1").Write 1
Else
   HMIRuntime.Tags("BinaryTag1").Write 0
End if

Note
Si vous voulez commuter une propriété (dont le type de valeur est booléenne), vous ne devez pas utiliser le script ci-dessus mais le suivant :

ScreenItems("Button1").Visible = Not ScreenItems("Button1").Visible

HMIRuntime.Tags("NewTag_2").Write HMIRuntime.Tags("NewTag_1").Read
HMIRuntime.Tags("NewTag_3").Write HMIRuntime.Tags("NewTag_2").Read
HMIRuntime.Tags("NewTag_4").Write HMIRuntime.Tags("NewTag_3").Read
HMIRuntime.Tags("NewTag_5").Write HMIRuntime.Tags("NewTag_4").Read

Dans le cas montré ci-dessus, les valeurs sont lues et écrites par la mémoire image des variables. Pour s'assurer que la variable a bien été lue avant de l'écrire, vous pouvez utiliser une fonction de lecture et d'écriture synchrone. Modifiez ainsi la fonction de lecture de "Read" en "Read(1),1" - comme dans l'exemple suivant :

HMIRuntime.Tags("NewTag_2").Write HMIRuntime.Tags("NewTag_1").Read(1) ,1
HMIRuntime.Tags("NewTag_3").Write HMIRuntime.Tags("NewTag_2").Read(1) ,1
HMIRuntime.Tags("NewTag_4").Write HMIRuntime.Tags("NewTag_3").Read(1) ,1
HMIRuntime.Tags("NewTag_5").Write HMIRuntime.Tags("NewTag_4").Read(1) ,1

Remarque :
Les fonctions de lecture et d'écriture synchrones correspondent aux GetTagxxxWait et SetTagxxxWait dans le monde ANSI C. Ces fonctions ont l'inconvénient de durer plus longtemps, car elles sont dépendantes du couplage et de l'API. La suite du traitement du script est arrêtée tant qu'une réponse de l'API n'est pas arrivée. Ces fonctions peuvent conduire à une perte de performance, et elles ne doivent donc être utilisées qu'à titre exceptionnel.  Les fonctions de lecture et d'écriture asynchrone sont nettement plus performantes car elles travaillent avec la mémoire image des variables. Ici la lecture et l'actualisation des variables sont deux fonctions séparées l'une de l'autre dans le processus. 
Les fonctions synchrones ne doivent être utilisées que lorsqu'il faut s'assurer que la variable a bien été lue ou écrite avant de traiter la suite du Script. 

Note :
Se référer aux descriptions de GetTag et de GetTagWait notées dans le Système d'Information WinCC sous :

• WinCC V6.0 - "Travailler avec WinCC > ANSI-C pour la création de fonctions et d'actions > Description de fonction > Fonction Interne > tag > get > GetTagBit > Comment travaille les fonctions GetTag"
• WinCC >= V6.2 -"Travailler avec WinCC > ANSI-C pour la création de fonctions et d'actions >  Fonction Interne > tag > Comment travaille les fonctions GetTag"

Instructions:
Vous pouvez utiliser l'instruction "sizeof()"en langage C pour définir la mémoire allouée aux variables C ou la taille des types de données C. Vous pouvez configurer une action C dans une vue (ex : action C sur événement clic souris sur bouton) qui utilise l'instruction sizeof().

"sizeof(type de données)" ou. "sizeof(Variable)"

L'instruction "sizeof()"-retourne la taille d'une variable ou d'un type de données en Byte. Vous pouvez visualiser le résultat en utilisant l'instruction "printf"-pour diriger le résultat dans une fenêtre Global Script ou. "APDIAG"-avec la fenêtre de sortie sur écran.

Les 2 images suivantes montrent l'utilisation de l'instruction "sizeof()"-et les sorties correspondantes dans une fenêtre de diagnostic pour estimer la taille d'un type de données C.

( 7 KB )  
Image 01 

( 12 KB )  
Image 02