Inhalt - INOSOFT GmbH

VisiWinNET 2005 

Prozessanbindung 

VisiWin 


Allgemeines 

Klassenbibliothek 

Systeme 

Werkzeuge 

Technische Infos 

Inosoft OPCServer 

Grundlagen und Hilfsmittel 

Protokolle


Prozessanbindung 

VisiWin 

® by INOSOFT ® 

VisiWinNET Itemeditor in SMART

Ohne ausdrückliche schriftliche Erlaubnis der INOSOFT GmbH darf der Inhalt des 

Handbuches nicht anderweitig verwendet werden. 

Den Inhalt des Handbuches haben wir auf Übereinstimmung mit der beschriebenen 

Software geprüft. Trotzdem können Abweichungen nicht ausgeschlossen werden. Aus 

diesem Grund können wir für eine völlige Übereinstimmung keine Gewähr geben. Der 

Inhalt des Handbuches wird regelmäßig auf Änderungen geprüft. Korrekturen sind in 

der nachfolgenden Ausgabe vorhanden. Verbessungsvorschläge werden dankbar 

angenommen. 

Legende 

Um auf besondere Einstellungen aufmerksam zu machen, werden in den INOSOFT- 

Dokumentationen folgende Symbole verwendet: 

Achtung Absätze mit diesem Zeichen sollten Sie besonders 

aufmerksam lesen - und beachten. 

Hinweis Wichtige Einstellung 

"additional informations". 

Tipp Viele Wege führen nach Rom, 

hier finden Sie eine Abkürzung. 

In Arbeit Funktionen in Vorbereitung, bzw. bereits implementiert, 

jedoch noch nicht für die Dokumentation aufbereitet. 

Beispiel 

ausführen 

Beispiel 

beobachten 

Anweisungen, die in einem Beispiel auszuführen sind. 

Ergebnisse, die durch die Ausführung der 

Beispielanweisungen zu beobachten sind. 

© / / ® 

Windows®, Windows NT®, Windows 2000® , Windows XP® 

sind eingetragene Warenzeichen der Firma Microsoft. 

Weitere mit ® erwähnte Produktnamen sind Warenzeichen der betreffenden 

Herstellerfirmen. 

INOSOFT GmbH 

VisiWinNETVersion: ab 6.04.0000 

erstellt am 18.10.2010

Inhalt 

1 Vorwort ..................................................................................................................... 1 

2 Einführung in die Prozessanbindung ........................................................................ 2 

2.1 Die sechs Leben der Prozessvariablen ........................................................................... 5 

3 Projektierung ............................................................................................................ 9 

3.1 Start des Variableneditors ............................................................................................ 9 

4 Definitionen der Prozessanbindung........................................................................ 10 

4.1 Kommunikationskanal................................................................................................ 11 

4.1.1 Kommunikationskanäle bearbeiten ......................................................................................... 16 

4.1.2 Kommunikationskomponenten ............................................................................................... 17 

4.2 Prozessvariable ......................................................................................................... 25 

4.2.1 Prozessvariablen bearbeiten...................................................................................................26 

4.3 Gruppe..................................................................................................................... 28 

4.3.1 Gruppen bearbeiten............................................................................................................... 29 

4.3.2 Verwendung von Gruppen ..................................................................................................... 29 

4.4 Einheitenklasse ......................................................................................................... 36 

4.4.1 Einheitenklassen bearbeiten...................................................................................................37 

4.4.2 Einheitenumschaltungen implementieren ................................................................................ 38 

4.4.3 FAQ zu Einheitenklassen ........................................................................................................52 

4.5 Einheit ..................................................................................................................... 53 

4.5.1 Einheiten bearbeiten.............................................................................................................. 54 

4.6 Struktur ................................................................................................................... 55 

4.6.1 Strukturen bearbeiten............................................................................................................ 56 

4.6.2 Verwendung von Strukturen .................................................................................................. 56 

4.7 Strukturelement........................................................................................................ 62 

4.7.1 Strukturelemente bearbeiten.................................................................................................. 63 

4.8 Multiplexer ............................................................................................................... 64 

4.8.1 Multiplexer bearbeiten ........................................................................................................... 65 

4.8.2 Beispiel Multiplexer................................................................................................................ 66 

4.9 Variablenadapter....................................................................................................... 69 

4.9.1 Variablenadapter bearbeiten .................................................................................................. 71 

4.9.2 Beispiel Variablenadapter....................................................................................................... 72 

5 Parameter der Definitionen der Prozessanbindung................................................ 77 

5.1 Abtastzeit ................................................................................................................. 79 

5.2 Adresse.................................................................................................................... 80 

5.3 Aktivierungsmodus.................................................................................................... 81 

5.4 Alias ........................................................................................................................ 81 

5.5 Beschreibung............................................................................................................ 82 

5.6 Browser ................................................................................................................... 82 

5.7 Browsereigenschaften ............................................................................................... 84 

5.8 Bytetausch ............................................................................................................... 85 

5.9 Daten direkt aus der Hardware lesen .......................................................................... 86 

5.10 Datentyp................................................................................................................. 87 

5.11 Definition aktiv ........................................................................................................ 88 

5.12 Einheitenklasse (Anzeige)......................................................................................... 88 

5.13 Einheitenklasse (Prozess) ......................................................................................... 88 

5.14 Einheitentext........................................................................................................... 88 

5.15 Einzeln beschreibbar ................................................................................................ 89 

5.16 Einzelzugriff auf Feldelemente .................................................................................. 90 

5.17 Ersatzwert............................................................................................................... 91 

5.18 Ersatzwert Modus .................................................................................................... 92 

5.19 Feldgröße ............................................................................................................... 93 

5.20 Fließkomma-Konvertierung IEEE-S5/S7...................................................................... 94 

I

5.21 Hysterese................................................................................................................ 95 

5.22 ItemID ................................................................................................................... 95 

5.23 Kommaverschiebung................................................................................................ 96 

5.24 Kommentar ............................................................................................................. 96 

5.25 Konfigurationsstatus ................................................................................................ 97 

5.26 Konfiguration im OPC-Server speichern...................................................................... 97 

5.27 Lesen wiederholen bei Schreib-/ Lesekonflikt ............................................................. 98 

5.28 Lesezugriffe ............................................................................................................ 99 

5.29 Maximalwert ........................................................................................................... 99 

5.30 Minimalwert .......................................................................................................... 100 

5.31 Name ................................................................................................................... 101 

5.32 nur Data-Callback-Interface V1.0 benutzen .............................................................. 102 

5.33 OPC-Server hat Unicode-Strings.............................................................................. 103 

5.34 OPC-Shutdown-Interface nicht verbinden................................................................. 104 

5.35 OPC-Servername ................................................................................................... 105 

5.36 Ordnungsnummer.................................................................................................. 106 

5.37 Ordnungsnummer als Byteoffset ............................................................................. 106 

5.38 Rechnername........................................................................................................ 107 

5.39 Schreibzugriffe ...................................................................................................... 107 

5.40 Separatorzeichen................................................................................................... 108 

5.41 Sicherheit.............................................................................................................. 109 

5.42 Standardsprache.................................................................................................... 110 

5.43 Startwerte nicht synchron einlesen.......................................................................... 111 

5.44 Steuerobjekt ......................................................................................................... 113 

5.45 Strukturzugriff ....................................................................................................... 115 

5.46 Synchrone Kommunikation ermöglichen................................................................... 116 

5.47 Text ..................................................................................................................... 117 

5.48 Treibername ......................................................................................................... 118 

5.49 Umschaltvariable ................................................................................................... 119 

5.50 Umschaltkennung .................................................................................................. 119 

5.51 Umschaltzustände.................................................................................................. 120 

5.52 URL...................................................................................................................... 120 

5.53 Variablenoptionen.................................................................................................. 121 

5.54 Variablen statisch aktivieren ................................................................................... 123 

5.55 Variablenwerte bei OPC Quality BAD nicht übernehmen ............................................ 124 

5.56 Variablen beim Deaktivieren weiterlesen.................................................................. 124 

5.57 Verbindungsversuche nach Initialisierungsphase wiederholen .................................... 125 

5.58 Version ................................................................................................................. 125 

5.59 VWE erzeugt Items (CallR-Server)........................................................................... 126 

5.60 Worttausch VT_I4, VT_UI4..................................................................................... 127 

5.61 Worttausch VT_R4, VT_R8 ..................................................................................... 129 

5.62 x1 ........................................................................................................................ 131 

5.63 x2 ........................................................................................................................ 132 

5.64 y1 ........................................................................................................................ 132 

5.65 y2 ........................................................................................................................ 132 

5.66 Zeitzonendifferenz ................................................................................................. 132 

5.67 zu deaktivierende Kanäle........................................................................................ 133 

5.68 Zugriffsart............................................................................................................. 133 

5.69 Zugriffspfad .......................................................................................................... 134 

6 Variablen anbinden ............................................................................................... 135 

6.1.1 VWEngine-Fenster............................................................................................................... 135 

6.1.2 Variablenauswahldialog ....................................................................................................... 135 

6.1.3 Systemvariablen.................................................................................................................. 137 

6.1.4 Funktionen.......................................................................................................................... 138 

6.2 Initialverhalten beim Formularwechsel ...................................................................... 140 

II

1 Vorwort 

Zu diesem Handbuch 

Dieses Handbuch enthält spezifische Informationen zur VisiWinNET Prozessanbindung. 

Enthalten sind unter anderem die Erklärung der beteiligten Komponenten, die 

Bedienreferenz des Editors und die Beschreibung der Definitionen der Prozessanbindung. 

Fragen und Probleme 

Bei technischen Fragen und Problemen wenden Sie sich bitte an Ihre zuständige INOSOFT 

Vertretung oder an den Support der INOSOFT GmbH unter Tel.:+49 (5221) 16 66 02 bzw. 

E-Mail: Support@INOSOFT.com 

Häufige Fragen und Probleme werden auch auf unserer Homepage unter www.inosoft.com 

behandelt. 

Dort finden Sie auch einen Supportbereich, in dem Sie sich mit Fragen direkt an unsere 

Zentrale wenden können. 

Vorwort 1

VisiWinNET 2005 Prozessanbindung 

2 Einführung in die Prozessanbindung 

Einführung in die Prozessanbindung / Die sechs Leben der Prozessvariablen / Kommunikationskanäle bearbeiten 2 

Eine Prozessvisualisierung stellt die Schnittstelle zwischen Mensch und Maschine dar. 

Prozessgrößen werden dargestellt, Benutzereingaben an Maschinen weitergeleitet. Die 

Ausgabe von Prozessgrößen soll allgemein verständlich, schnell erfassbar und handhabbar 

sein (grafische Darstellungen, Umrechnungen von Maschinengrößen in gebräuchliche 

Einheiten, textuelle Wiedergabe von Zuständen, ...). Eingabeelemente sollen den 

physikalische Ebenbildern entsprechen (Schalter, Taster, Schieberegler, ...). 

Die VisiWinNET-Prozessvisualisierung stellt Ein- und Ausgabeelemente in Form von 

Steuerelementen zur Verfügung. Jedes Steuerelement kann eine oder mehrere 

Informationen darstellen oder zur Maschinensteuerung übertragen. Dazu ist es nötig, die 

einzelnen Informationen zuzuordnen: Für jedes Steuerelement muss festgelegt werden, 

welche Prozessgröße es darstellen oder beeinflussen soll. 

Eine Prozessgröße ist eine Informationszelle, die zwischen Maschine und Visualisierung 

ausgetauscht wird. Die obenstehende Grafik zeigt nur die Endpunkte des 

Kommunikationsweges. Dazwischen gibt es eine Reihe von Zwischenstationen, die die 

Informationen empfangen und weiterleiten. Diese Zwischenstationen dienen als 

Verzweigungs- und Verbindungspunkte zu weiteren Systemen. Als Verbindungspunkte 

dienen sie zur Optimierung des Datentransfers. Als Verzweigungspunkte dienen die 

Zwischenstationen zur Verteilung von Daten an andere Systeme. Durch diesen Aufbau bleibt 

eine Modularität des Projektes erhalten, die die heute gängige Client-Server-Fähigkeit voll 

unterstützt, ohne ein übermäßiges Datenaufkommen zu erzeugen.



Anhand des folgenden Blockschaltbildes werden diese Zwischenstationen als Komponenten 

der Prozessanbindung vorgestellt. Weiterführende Informationen über die Komponenten 

werden als Querverweise angegeben. 

Komponenten der VisiWinNET Prozessanbindung 

Applikation 

Steuerelement 

e 

OPC Server 

Variablen- 

Client 

Komponente Beschreibung 

VisiWinNET- 

Steuerelemente/ 

Klassen 

Kommunikationskomponenten 

Entwicklungsumgebung 

Browser 

OPC Server 

lokal 

oder 

Netzwerk 

COM/ 

DCOM 

VisiWinNET Manager 

Variableneditor 

VWOPC 

Server 

Variablenkern 

Projektdatenbank 

Variablenauswahldialog 

Steuerelemente 

VisiWin- 

Treiber 

Die Steuerelemente gestalten die Oberfläche der 

Visualisierungsapplikation. Es gibt Steuerelemente zur 

numerischen oder grafischen Ein-/ Ausgabe von Prozessdaten. Die 

VisiWinNET-Klassen ermöglichen den Austausch von 

Informationen ohne grafische Anbindung (die Funktionen sind im 

Programmcode aufzurufen). Zur Laufzeit binden sich 

Steuerelemente und Klassen an den Variablenclient an. Zur 

Entwicklungszeit wird den Steuerelementen über den 

Variablenauswahldialog eine Projektierunterstützung zur 

Verfügung gestellt. Damit ist es möglich, 

Prozessvariablendefinitionen auszuwählen, die zur Laufzeit die 

darzustellenden Prozesswerte repräsentieren. 

VisiWinNET- 

Treiber



Weiterführende Informationen befinden sich im Handbuch 

"VisiWinNET Klassenbibliothek". 

Variablenclient Der Variablenclient sammelt die Datenanforderungen von 

Steuerelementen und VisiWinNET-Klassen einer 

Visualisierungsapplikation. Damit wird die gesamte Applikation als 

nur ein Client beim Variablenkern angemeldet. Der Austausch von 

Daten über den Variablenclient verläuft vollautomatisch. Einzig 

das Fehlerprotokoll des Variablenclients ist konfigurierbar. 

Variablenkern Der Variablenkern wird über den VisiWinNET Manager gestartet. 

Seine Aufgabe ist es, den in der Projektdatenbank definierten 

Datenaustausch zwischen den Kommunikationskomponenten und 

den angeschlossenen Visualisierungsapplikationen zu regeln. 

Außerdem dient er als Datenlieferant für andere Systeme (wie z.B. 

den Alarmserver). Eine ausführliche Beschreibung über die 

Möglichkeiten und Konfigurationseinstellungen befindet sich im 

Handbuch "VWNManager". 

(VW)OPC-Server OPC-Server stellen eine von zwei Kommunikationsmöglichkeiten 

mit einer SPS unter VisiWinNET dar. Sie benutzen ein 

hardwarespezifisches Protokoll zum Austausch von Daten mit der 

SPS. Die Verbindung zum Variablenkern ist über die OPC- 

Spezifikation festgelegt. Weitere Informationen über Eigenschaften 

und Möglichkeiten von OPC-Servern befinden sich im Handbuch 

"VWOPC-Server". 

VisiWin-Treiber Die andere Kategorie von Kommunikationskomponenten sind die 

VisiWin-Treiber. Zum Datenaustausch mit der SPS wird das 

hardwarespezifische Protokoll benutzt. Die Daten werden jedoch 

über einen geteilten Speicherbereich zum Variablenkern 

übermittelt. Daher müssen VisiWin-Treiber im Gegensatz zu OPC- 

Servern auch immer auf dem Rechner installiert werden, auf dem 

auch der Variablenkern läuft. Die Schnittstelle ist somit nur 

kompatibel mit VisiWin-Produkten. 

Weitere Informationen über Eigenschaften und Möglichkeiten von 

VisiWin-Treibern befinden sich im gleichnamigen Handbuch. 

VisiWinNET-Treiber VisiWinNET-Treiber als neueste Generation von 

Kommunikationskomponenten beinhalten ein den Funktionen von 

OPC-Servern ähnliches Kommunikationsmodell. Die Schnittstelle 

ist jedoch visualisierungsspezifisch. Mehr Informtionen dazu 

befinden sich im Handbuch "VisiWinNET-Treiber". 

Projektdatenbank Die Projektdatenbank enthält die Definitionen der 

Prozessanbindung. Diese werden in der Entwicklungsumgebung 

über den Variableneditor projektiert. Zur Laufzeit werden die 

Daten vom Variablenkern interpretiert. Weiter Informationen über 

die Definitionen der Prozessanbindung und deren Parameter 

befinden sich in den gleichnamigen Kapiteln in diesem Handbuch.



Variableneditor Der Variableneditor dient zur Projektierung der Definitionen der 

Prozessanbindung. Er ist in die Entwicklungsumgebung integriert. 

Die hier vorgenommenen Definitionen landen in der 

Projektdatenbank. Eine Bedienreferenz befindet sich im Kapitel 

"Projektierung" in diesem Handbuch. 

2.1 Die sechs Leben der Prozessvariablen 

Die OPC-Spezifikation beschreibt das Itemobjekt als Repräsentation eines Prozesswertes im 

OPC-Server: Über das Itemobjekt kann dieser Wert gelesen oder geschrieben werden, 

optionale Parameter ermöglichen z.B. Grenzwertüberwachungen, über Zusatzinformationen 

können Übertragungsfehler und Datenaustauschzeitpunkt ermittelt werden. In VisiWinNET 

wird diese Spezifikation voll unterstützt, durch den Systemaufbau werden jedoch folgende 

zusätzliche Erweiterungen möglich: 

• Betrieb von VisiWin-Treibern im Rahmen der Prozessvariablendefinitionen 

• Paralleler Betrieb von mehreren Kommunikationskomponenten (VisiWin-Treiber und 

OPC-Server), die aus der Sicht der Applikation nur einen einzigen Datenpool darstellen. 

• Optimierungsverfahren für den blockorientierten Datenzugriff über 

Datentyperweiterungen. 

• Optimierungsverfahren für mehrere Clients (Ausschluss von Mehrfachanfragen). 

• Umrechnung von Prozessvariablenwerten in Abhängigkeit von der aktuellen Sprache 

eines Clients oder von dem Wert einer Steuervariablen. 

Diese Möglichkeiten erfordern eine Erweiterung der Prozessvariablendefinition in 

VisiWinNET. Im Folgenden werden die wichtigsten Eigenschaften zum Zugriff auf eine 

Prozessvariable in den Komponenten der Prozessanbindung beschrieben. 

In der SPS 

In der SPS repräsentiert eine Prozessvariable einen Prozesswert, der über das 

Schnittstellenprotokoll ausgetauscht werden kann. Um Werte aus der SPS lesen oder 

schreiben zu können, muss die Startadresse und die Bytelänge bekannt sein. 

Die Startadresse kann bei einer SPS, die eine symbolische Adressierung unterstützt, ein 

Bezeichner sein, der eine Aussage über die Verwendung des Prozesswertes trifft. Die SPS 

ermittelt anhand einer Bezeichnertabelle die entsprechende Zelle im Speicher. Wird keine 

symbolische Adressierung unterstützt, so kann die SPS über die direkte Angabe einer 

spezifischen Adresskennung auf die angesprochene Speicherzelle zugreifen. 

Die Länge bestimmt die Anzahl von Bytes, die für die vollständige Übertragung des Wertes 

aus dem SPS-Speicher nötig sind.


In der Kommunikationskomponente 


Kommunikationskomponenten sind die Bindeglieder zwischen dem Variablenkern und der 

SPS-Schnittstelle. Die Aufgabe der Kommunikationskomponente ist es, Datenanforderungen 

des Kernels zu bedienen. SPS-seitig müssen die Prozesswerte über die für die SPS 

verständliche Adress-/ Längendefinition angesprochen werden. Auf der Seite des 

Variablenkerns zeigen OPC-Server und VisiWin-Treiber grundsätzlich verschiedene 

Verhalten: 

VisiWin-Treiber erwarten vom Variablenkern genau die SPS-verständlichen Informationen 

"Startadresse" und "Länge" zum Zugriff auf einen Prozesswert. Der Variablenkern muss also 

die in einer Prozessvariablendefinition enthaltenen Informationen passend aufbereiten. 

In OPC-Servern ist ein Prozesswert über die sogenannte "ItemID" anzusprechen. Die ItemID 

bezeichnet das Objekt, das den Prozesswert repräsentiert, im OPC-Server eindeutig. Sie 

kann entweder die Angabe der Startadresse (symbolisch oder nicht) oder ein neuer und 

damit verständlicherer Bezeichner für den Prozesswert sein. Die Länge des 

auszutauschenden Prozesswertes wird über den "Datentyp" geregelt. OPC-Server können die 

Angabe eines Datentyps verarbeiten. Um das Objekt jedoch instanzieren zu können, müssen 

diese Informationen vor dem eigentlichen Datenaustausch bekannt sein. Die Informationen 

über Items werden dem OPC-Server entweder in Form einer Definitionsliste während der 

Initialisierung (eigene Definitionsdatei/ OPC-Server-Projektdatei) oder zur Laufzeit (CallR- 

Server) zur Verfügung gestellt. 

Items werden zur Laufzeit Gruppen zugeordnet, die dazu dienen, den Datenaustausch zu 

steuern. So kann z.B. über die Deaktivierung einer Gruppe der Zugriff auf alle darin 

enthaltenen Items gestoppt werden. 

Sowohl VisiWin-Treiber als auch OPC-Server erschaffen ein Speicherabbild der SPS. Sie 

haben eigene Zykluszeiten, in denen die angeforderten Prozessvariablen aus der SPS 

ausgelesen werden. Diese Zykluszeit hat jedoch nichts mit der Rückgabe an den 

Variablenkern zu tun. Während VisiWin-Treiber im Zyklus des Variablenkerns ausgelesen 

werden, haben OPC-Server die Fähigkeit, asynchron mit einer einstellbaren Abtastzeit für 

jede Gruppe die angeforderten Daten zurückzumelden. 

In der Projektdatenbank 

Die Projektdatenbank enthält alle für das Projekt relevanten Daten. In der 

Entwicklungsumgebung werden Definitionen in den Editoren projektiert. Steuerelemente, 

die zur Laufzeit einen Bezug zu einer Definition herstellen sollen, können die in der 

Projektdatenbank enthaltenen Definitionen zur Auswahl auflisten. Zur Laufzeit werden die 

Definitionen von der zuständigen Serverkomponente interpretiert.


Im Variablenkern 


Der Variablenkern stellt das Bindeglied zwischen den Kommunikationskomponenten, den 

Visualisierungsapplikationen und anderen Systemen (Alarmsystem, Trends, ...) dar. Während 

der Initialisierung erstellt er anhand der Definitionen der Projektdatenbank ein 

Speicherabbild aller Prozessvariablen, die sogenannte Prozessdatenbank. Wird ein lesender 

oder schreibender Zugriff auf einen Prozesswert angefordert, aktiviert der Kernel den Zugriff 

auf die entsprechende Variable in der Kommunikationskomponente. Nach dieser 

Initialisierung werden die Daten zyklisch oder getriggert ausgetauscht. 

Die Anforderung eines Prozesswertes erfolgt über den Prozessvariablenbezeichner aus der 

Projektdatenbank und die Angabe der Kommunikationskomponente. Ein Prozesswert kann 

also insgesamt drei verschiedene Bezeichner haben: 

1) Die Adressangabe in der SPS, 

2) Die ItemID in der Kommunikationskomponente und 

3) Den Bezeichner in der Visualisierung. 

Dies ist jedoch nicht sinnvoll. Die Vergabe eines Bezeichners in der 

Projektdatenbankdefinition sollte nur dann genutzt werden, wenn die SPS keine symbolische 

Adressierung unterstützt und die Kommunikationskomponente keine Möglichkeit zur 

Verfügung stellt, den Prozesswert zu benennen. Dies ist z.B. bei VisiWin-Treibern der Fall. 

Die Definitionen in der VisiWinNET-Projektdatenbank enthalten die Möglichkeit, erweiterte 

Datentypen (Felder und Strukturen) zu projektieren. Über den Zugriff auf eine 

Prozessvariable mit Datentyperweiterung ist eine erhebliche Leistungssteigerung des 

Systems möglich. Prozesswerte können damit blockweise übertragen werden. Weitere 

Informationen über die Optimierung von Datenzugriffen durch erweiterte Datentypen finden 

sich im Kapitel "Optimierung der Kommunikation" (für VisiWin-Treiber) im Handbuch 

"VisiWin Treiber". 

Im Variablenclient 

Der Variablenclient verwaltet den Datenaustausch einer Visualisierungsapplikation. 

Geladene Steuerelemente oder instanzierte VisiWinNET-Klassen melden sich beim 

Variablenclient an. Dieser reicht die Anforderung von Prozesswerten zum Variablenkern 

weiter. Nach der Anmeldung wird der Datenaustausch je nach Bedarf zyklisch oder 

ereignisgesteuert ausgeführt. Auch der Variablenclient legt ein Prozessabbild an, jedoch nur 

für die von ihm benötigten Prozesswerte. 

Im Steuerelement 

Damit ein Steuerelement den Zugriff auf ein Prozesswert in der SPS erhält, sind folgende 

Informationen nötig: 

• An welche Serverkomponente muss die Anfrage gerichtet werden (Multiserverprojekt, 

Netzwerkpfad)? 

• Über welche Kommunikationskomponente kann der Prozesswert erreicht werden 

(Kommunikationskanal, Netzwerkpfad)?



• Wie muss die Prozessvariable in der Kommunikationskomponente angesprochen werden 

(ItemID)? 

• Wie ist der Index des Feldelementes, wenn die Prozessvariable als Feld definiert ist? 

• Wie ist der Name eines Strukturelementes, wenn die Prozessvariable als Struktur 

definiert wurde? 

Zur Entwicklungszeit werden die Definitionen der Projektdatenbank auf den 

Eigenschaftenseiten der "VWItem"-Eigenschaft aufgelistet. Ist eine Prozessvariable vom 

Datentyp einer Struktur oder eines Feldes, so werden unter der Prozessvariablendefinition 

die Struktur- und Feldelemente aufgelistet. Der Name und die Darstellung auf der 

Eigenschaftenseite suggerieren die Auswahl einer Prozessvariablen. Tatsächlich aber wird 

ein eindeutiger Bezeichner für den Prozesswert im System gewählt. Wird ein Eintrag 

selektiert, so erscheint als Ergebnis ein Bezeichner, der neben der ItemID auch noch den 

Namen des Kommunikationskanals und unter Umständen auch das gewählte Struktur- 

/Feldelement enthält. Das Handling in den Steuerelementen verhält sich also vollständig 

OPC-konform. Die Auflösung des gewählten Bezeichners muss jedoch in den verschiedenen 

Komponenten der Prozessanbindung vorgenommen werden.


3 Projektierung 

3.1 Start des Variableneditors 

Projektierung / Start des Variableneditors / Kommunikationskanäle bearbeiten 9 

VisiWin stellt einen Editor zum Projektieren der Prozessanbindung zur Verfügung. Dieser 

wird bei der Installation von VisiWinNET in die Entwicklungsumgebung integriert. Die 

projektierten Definitionen werden in der Projektdatenbank gespeichert. 

Der Variableneditor wird im VisiWinNET-Projektexplorer durch das Symbol repräsentiert. 

Dies ist der Hauptzugriffsknoten auf die Definitionen der Prozessanbindung. 

Nach dem erstmaligen Anklicken des Knotens "Variablen" initialisiert sich der Editor im 

Projektexplorer. Es werden folgende Zugriffsknoten eingefügt: 

Kanäle Kanäle legen die Kommunikationskomponenten fest, über die mit 

den angeschlossenen Steuerungen kommuniziert wird. Die Kanäle 

werden als Unterknoten dargestellt. Die in den Kanälen 

projektierten Prozessvariablendefinitionen befinden sich im 

Tabelleneditor. 

Gruppierungen Hier werden als Unterknoten die Gruppendefinitionen des 

Projektes dargestellt. Im Tabelleneditor wird eine Ansicht auf die 

Prozessvariablen angezeigt, die der jeweiligen Gruppe zugeordnet 

ist. 

Einheitenklassen Enthält die Umrechnungsdefinitionen des Projektes. Eine 

Einheitenklasse kann variablenwert- oder sprachabhängig wirken. 

Die Angabe der Umrechnungswerte erfolgt über die Angabe von 

Einheitendefinitionen im Tabelleneditor. 

Strukturdefinitionen Die Strukturdefinitionen des Projektes werden als Unterknoten im 

Projektexplorer angezeigt. Die Elemente der jeweiligen Struktur 

sind im Tabelleneditor zu projektieren.


4 Definitionen der Prozessanbindung 

Definitionen der Prozessanbindung / Start des Variableneditors / Kommunikationskanäle bearbeiten 10 

Im Folgenden eine Auflistung der Definitionen der VisiWinNET-Prozessanbindung. 

Zusätzlich wird die Information angegeben, in welcher Produktvariante die Definition 

vorhanden ist. 

Definition VisiWinNET 

Standard 

Kommunikationskanal (VisiWin 

Treiber) 

Kommunikationskanal (OPC- 

Server) 

Kommunikationskanal 

(VisiWinNET Treiber) 

Prozessvariable 

Gruppe 

Einheitenklasse 

(variablenabhängig) 

Einheitenklasse (sprachabhängig) 

Einheit 

Struktur 

Strukturelement 

Multiplexer 

Variablenadapter 

VisiWinNET 

Compact 

VisiWinNET Embedded


4.1 Kommunikationskanal 

Definitionen der Prozessanbindung / Kommunikationskanal / Kommunikationskanäle bearbeiten 11 

Die Definition eines Kommunikationskanals legt fest, mit welcher 

Kommunikationskomponente Daten ausgetauscht werden sollen. Dabei sind mehrere 

Kategorien von Kommunikationskomponenten zu unterscheiden: 

• OPC-Server 

• OPC-UA Server 

• VisiWin-Treiber 

• VisiWinNET-Treiber 

Die Kategorie der Kommunikationskomponente muss beim Anlegen eines neuen 

Kommunikationskanals festgelegt werden. 

Je nach Kategorie bietet ein Kommunikationskanal u.a. folgende Funktionalität: 

OPC-Server/ OPC- 

UA-Server: 

• Festlegung des Netzwerkstandortes (von wo soll der OPC- 

Server gestartet werden) 

• Unterscheidung zwischen Standard und CallR 

• Festlegung der Feldelementezugriffe 

• Strukturierung der Ansicht 

VisiWin- 

• Aufruf des Konfigurationstools aus der Entwicklungsumgebung 

Treiber/VisiWinNET- 

Treiber 

• Automatische Auflistung aller installierten Treiber 

Aufgrund des unterschiedlichen Kommunikationsverhaltens von VisiWin-Treibern und 

OPC-Servern haben die Kommunikationskanäle der entsprechenden Kategorie 

unterschiedliche Parameter. 

VisiWin Treiber werden von der "Compact"-Produktvariante nicht 

unterstützt.


Parameter des Kommunikationskanals 

Für OPC-Server 

Name Beschreibung 


Beschreibung Gibt einen beschreibenden Text des OPC-Servers an. 

Browser Legt die Komponente zum Übernehmen von 

Variableninformationen fest 

Browser- 

eigenschaften 

Legt die Einstellungen für den Browser fest 

Bytetausch Optionale Datenkonvertierung beim Zugriff auf Strukturen als 

Bytestream. 

Daten direkt aus der 

Hardware lesen 

Bestimmt die Datenquelle beim synchronen Lesen. 

Definition aktiv Bestimmt, ob zur Laufzeit die Objektdefinition gültig ist. 

Einzelzugriff auf 

Feldelemente 

Fließkommakonvertierung 

IEEE- 

S5/S7 

Gibt an, ob der Zugriff auf Feldelemente einzeln erfolgen kann. 

Optionale Datenkonvertierung beim Zugriff auf Strukturen als 

Bytestream. 

Kommentar Wahlfreier Kommentar zur Definition. 

Konfiguration im 

OPC-Server-Projekt 

speichern 

Legt fest, wo die Konfigurationseinstellungen eines INOSOFT OPC- 

Servers gespeichert werden 

Konfigurationsstatus Gibt an, ob ein Konfigurationsdialog aus der 

Entwicklungsoberfläche zu starten ist und ob der OPC-Server 

bereits konfiguriert wurde. 

Lesen wiederholen 

bei Schreib-/ 

Lesekonflikt 

Schützt vor Datenverlusten bei einem Schreib-/Lesekonflikt im 

Variablenkern. 

Name Bezeichner der Definition. 

nur Data-Callback- 

Interface V1.0 

benutzen 

Zugriffsvariante auf das Interface des OPC-Servers. 

OPC-Servername Registrierter Name des OPC-Servers 

OPC-Server hat 

Unicode-Strings 

OPC-Shutdown- 

Interface nicht 

verbinden 


Bytestream. 

Bestimmt, wie sich der Variablenkern beim Beenden der OPC- 

Serverapplikation verhält. 

Rechnername Netzwerkname des Rechners, auf dem der OPC-Server installiert 

ist und von dem er gestartet werden soll.



Separatorzeichen Trennzeichen für die Namensräume im Variableneditor. 

Startwerte nicht 

synchron einlesen 

Optionale Optimierung beim Starten des Projektes. 

Strukturzugriff Entscheidet, wie auf Prozessvariablen vom Datentyp einer Struktur 

zugegriffen werden soll. 

Variablen statisch 

aktivieren 

Variablenwerte bei 

OPC Quality BAD 

nicht übernehmen 

Verbindungs- 

versuche nach 

Initialisierungsphase 

wiederholen 

Worttausch VT_I4, 

VT_UI4 

Worttausch VT_R4, 

VT_R8 

Bestimmt den Datenaustausch zwischen Variablenkern und OPC- 

Server. 

Legt fest, welcher Wert in den Variablenkern geschrieben wird, 

wenn eine Variable vom OPC-Server übertragen wird, deren 

Quality-Flag nicht "QUALITY_GOOD" ist. 

Legt fest, ob nach der Initialisierungsphase weiterhin versucht 

wird, eine Verbindung zum OPC-Server aufzubauen 


Bytestream. 


Bytestream. 

Version Registrierte Versionsnummer des OPC-Servers 

VWE erzeugt Items 

(CallR-Server) 

Legt fest, ob der OPC-Server als CallR-Server 

Prozessvariablendefinitionen aus der Projektdatenbank bezieht.


Für OPC-UA-Server 



Beschreibung Gibt einen beschreibenden Text des OPC-Servers an. 



Browser- 

eigenschaften 



Einzelzugriff auf 

Feldelemente 

Gibt an, ob der Zugriff auf Feldelemente einzeln erfolgen kann. 

Kommentar Wahlfreier Kommentar zur Definition. 

Lesen wiederholen 

bei Schreib-/ 

Lesekonflikt 

Schützt vor Datenverlusten bei einem Schreib-/Lesekonflikt im 

Variablenkern. 

Name Bezeichner der Definition. 

OPC-Servername Registrierter Name des OPC-Servers 


Sicherheit Sicherheitseinstellungen für die Verbindung und Kommunikation 

zwischen Kern und UA-Server. 




URL Verbindungsendpunkt des OPC-UA-Servers. 

Variablen statisch 

aktivieren 

Variablenwerte bei 

OPC Quality BAD 


Variablen beim 

Deaktivieren 

weiterlesen 

Verbindungs- 

versuche nach 

Initialisierungsphase 

wiederholen 

Bestimmt den Datenaustausch zwischen Variablenkern und OPC- 

Server. 

Legt fest, welcher Wert in den Variablenkern geschrieben wird, 



Legt fest, das Variablen, die nicht mehr von der Applikation 

benötigt und deshalb im Variablenkern abgemeldet werden, 

trotzdem aus der Kommunikationskomponente weiter angefordert 

werden. 

Legt fest, ob nach der Initialisierungsphase weiterhin versucht 

wird, eine Verbindung zum OPC-Server aufzubauen


Für VisiWin/VisiWinNET-Treiber 



Beschreibung Gibt einen beschreibenden Text des VisiWin-Treiber an. 



Browser- 

eigenschaften 


Definition aktiv Bestimmt, ob zur Laufzeit Daten mit dem VisiWin-Treiber 

ausgetauscht werden. 

Kommentar Wahlfreier Kommentar zum Objekt 

Konfigurationsstatus Gibt an, ob ein Konfigurationsdialog aus der 

Entwicklungsoberfläche zu starten ist und ob der VisiWin-Treiber 

bereits konfiguriert wurde. 

Name Bezeichner des Objektes 





Treibername Registrierter Name des VisiWin-Treibers



4.1.1 Kommunikationskanäle bearbeiten 

Kommunikationskanäle werden im Projektexplorer unter dem Knoten "Kanäle" dargestellt. 

Jeder Kanal beinhaltet: 

• einen editierbaren Parametersatz: Hier können verschiedene Kommunikationsverhalten 

eingestellt werden. 

• ggf. Prozessvariablendefinitionen: Prozessvariablen werden im Tabelleneditor angezeigt. 

Sie beinhalten die Informationen zum Zugriff auf die Variablen der angeschlossenen 

Steuerungen. 

Die Funktionen zum Projektieren von Kommunikationskanälen stehen im Tabelleneditor 

nach dem Markieren des Knotens "Kanäle" zur Verfügung: 

Neu erzeugen Über den Eintrag "Neu" im Kontextmenü des Knotens 

"Variablen→Kanäle" öffnet sich ein Dialog zum Festlegen der 

grundlegenden Eigenschaften des neuen Kommunikationskanals. 

Hier sind folgende Einstellungen vorzunehmen: 

Parameter 

bearbeiten 

• Name: Ein wahlfreier Name für den Kanal. Der Name muss 

innerhalb der Kommunikationskanäle des Projektes eindeutig 

sein. Verweise auf Prozessvariablen in der Applikation 

beziehen diesen Namen ein (z.B. "Ch1.w0" bezeichnet die 

Variable "wo" im Kommunikationskanal mit dem Namen "Ch1". 

• Kanaltyp: Entweder OPC oder Treiber. Die Einstellung ist 

abhängig von der zur Verfügung stehenden 

Kommunikationskomponente. 

• OPC-Server/ Treiber: Über die -Schaltfläche wird ein Dialog 

geöffnet, der die installierten Kommunikationskomponenten 

des gewählten Kanaltyps auflistet. Über diesen Dialog kann 

eine Kommunikationskomponente ausgewählt werden. 

Nach diesen Arbeitsschritten können Prozessvariablendefinitionen 

manuell oder über die Browse-Funktion in dem entsprechenden 

Kanal projektiert werden. 

Für jeden Kanal wird ein Knoten im Projektexplorer angezeigt. 

Über diesen Knoten wird zu den Prozessvariablendefinitionen des 

Kommunikationskanals navigiert. 

Nach dem Markieren eines Kommunikationskanals im 

Tabelleneditor zeigt die VisiWinNET-Eigenschaftenseite die 

Parameter des Kanals an. Hier vorgenommene Änderungen 

werden in der Projektdatenbank gespeichert.


Definitionen der Prozessanbindung / Kommunikationskanal / Kommunikationskomponenten 17 

Löschen Eine oder mehrere Kommunikationskanäle können gelöscht 

werden, indem: 

• zuerst die zu löschenden Kanäle im Tabelleneditor markiert 

werden (Klick auf die Selektorspalte am linken Tabellenrand 

ggf. bei gehaltener Strg- oder Shift-Taste für eine 

Mehrfachselektion) 

• Anschließend im Kontextmenü des Tabelleneditors der Eintrag 

"Löschen" gewählt wird. 

Browsen Variablendefinitionen können ggf. über eine Browser-Komponente 

in das Projekt übernommen werden. (Siehe auch Parameter 

"Browser"). Im Kontextmenü des Kommunikationskanalknotens 

wird die Browse-Funktion aufgerufen. 

4.1.2 Kommunikationskomponenten 

Als Kommunikationskomponenten bezeichnet die VisiWin-Literatur die Gerätetreiber, 

die das spezifische Protokoll einer SPS unterstützen und mit dem Variablenkern der 

Visualisierung Prozesswerte austauschen. 

Die entscheidenden drei Faktoren zum Finden der passenden 

Kommunikationskomponenten sind: 

• Die SPS, mit der kommuniziert werden soll. Die Kommunikationskomponente muss auf 

das spezifische Protokoll angepasst sein. 

• Das verwendete Gerät, über das die Kommunikation stattfindet. Einige Steuerungen 

beinhalten mehrere Schnittstellen oder es gibt Adapter, die die vorhandenen 

Schnittstellen adaptieren. 

• Natürlich auch die Verfügbarkeit unterschiedlicher Kommunikationskomponenten, die 

zur SPS und zum Kommunikationsweg passen. Denn nur wer die Wahl hat, hat auch die 

Qual. 

Stehen also verschiedene Kommunikationskomponenten zur Wahl, muss eine 

Entscheidung getroffen werden.


Kriterien zur Entscheidungsfindung 


Der VisiWinNET Variablenkern unterstützt drei verschiedene Kategorien von 

Kommunikationskomponenten: 

VisiWin-Treiber Seit Windows 95 in nahezu unveränderter Form im Einsatz. 

Unterstützen Einzelvariablen und Strukturen zum blockweisen 

übertragen von Daten. Prozesswerte werden Gruppen 

zugeordnet, die den Datentransfer über einstellbare Zyklen oder 

Trigger steuern. 

OPC-Server Universelle, visualisierungsunabhängige Schnittstelle, durch die 

OPC-Foundation spezifiziert. Beinhaltet zur Datenübernahme 

das "Browser"-Interface, über das sich projektierte 

Prozessgrößendefinitionen im Idealfall aus der SPS- 

Entwicklungsumgebung direkt in die Projektdatenbank 

übernehmen lassen. Netzwerkfähige Schnittstelle über DCOM 

oder eigenen Protokollstack (OPC UA). 

VisiWinNET-Treiber Auf Basis des .NET Framework implementiert. Garantieren 

damit eine größtmögliche Durchgängigkeit in den 

unterschiedlichen Betriebssystemen XP/CE. Beinhalten optional 

zur Datenübernahme einen "Browser"-ähnlichen Mechanismus 

und weitere Unterstützungen zur Entwicklungszeit. Das 

Verhalten zur Laufzeit ist speziell auf die Beseitigung von 

Synchronisationsproblemen bei OPC-Servern optimiert. 

OPC-Server werden üblicherweise vom entsprechenden Steuerungshersteller 

angeboten. Gegebenenfalls haben auch Drittanbieter alternative Angebote. Eine breite 

Palette von Steuerungen kann über VisiWin-Treiber angesprochen werden. Hier lohnt 

sich ein Blick in die INOSOFT-Preisliste. Die Palette von zur Verfügung stehenden 

VisiWinNET-Treibern beschränkt sich nicht nur auf die INOSOFT-Produktion. Hier steht 

ein Treiber-Toolkit zur Verfügung, das die Implementierung eigener Protokolle auf Basis 

der Programmiersprache C# ermöglicht. 

Die oben in der Reihenfolge ihrer Entstehungsgeschichte aufgeführten Kategorien 

unterscheiden sich bezüglich Betriebssystem, Netzwerkfähigkeit und Funktion. Im 

Folgenden die wichtigsten Eckdaten zur Entscheidungsfindung als Stichworte. 

Fragenkatalog zur Entscheidungsfindung 

Betriebssystem Unter welchem Betriebssystem soll der Anschluss an die SPS 

erfolgen? 

Netzwerkfähigkeit Befindet sich die Anbindung auf dem Visualisierungsrechner 

oder einem anderen Rechner im Netzwerk? 

Projektier- 

unterstützung 

Visualisierungs- 

unabhängigkeit 

Ist die Menge der zu visualisierenden Daten umfangreich oder 

ändert sie sich im Verlauf der Entwicklung noch? Wie 

komfortabel können vom SPS-Programmierer geänderte Daten 

im Projektverlauf mit der Visualisierung abgeglichen werden? 

Müssen ggf. andere Applikationen mit der 

Kommunikationskomponente direkt Daten austauschen?



Datenkonsistenz Sind sequenzielle Kommunikationsabläufe mit Timing zu 

implementieren, die die üblichen Anforderungen der Konsistenz 

zwischen Anzeige und SPS-Speicher überschreiten? 

Optimierungen Belastet das zu übertragende Datenvolumen die 

Kommunikationsschnittstellen, so dass Optimierungsverfahren 

bei der Übertragung zu wählen sind? 

Die hier aufgeführten Kriterien werden in den folgenden Kapiteln näher erläutert. 

4.1.2.1 Betriebssystem 

Auf den Standard-Betriebssystemen sind keine Einschränkungen zu erwarten. In Bezug 

auf Windows CE sind folgende Einschränkungen zu nennen: 

• VisiWin-Treiber sind nicht unter CE lauffähig. 

• OPC-Server sind unter CE als spezielle Varianten generell zu verwenden. Nicht alle OPC- 

Server unterstützen jedoch diese Konstellation. Gegebenenfalls ist Rücksprache mit dem 

Hersteller zu nehmen. 

• VisiWinNET Treiber sind gerade unter dem Gesichtspunkt entwickelt worden, auch 

unter Windows CE zu arbeiten. Jedoch sind hier etwaige Hardwareabhängigkeiten zu 

beachten, die in der Preisliste und der spezifischen Treiberdokumentation aufgeführt 

werden.



4.1.2.2 Netzwerkfähigkeit 

Kommunikationskomponenten sollen ggf. nicht lokal auf dem Visualisierungsrechner laufen, 

sondern über ein Netzwerk angesprochen werden. 

Generell gilt: 

• VisiWin-Treiber sind nicht netzwerkfähig 

• OPC-Server sind als netzwerkfähig spezifiziert. Bis zur Spezifikation 3.0 (OPC-DA) 

verwenden OPC-Server für ihre Netzwerkfähigkeit DCOM (Distributed COM). Gerade 

DCOM aber stellte sich in den letzten Jahren als eklatante Sicherheitslücke im Windows- 

Betriebssystem dar und wird von Microsoft selbst nicht mehr weiterentwickelt. In der 

Praxis ist der Einsatz dieser OPC-Server im Netzwerk also unter sicherheitsrelevanten 

Gesichtspunkten kritisch zu betrachten. 

OPC-Server der neueren Generation (OPC UA) stellen dagegegen einen eigenen 

Kommunikationsstack zur Verfügung, dessen Sicherheitslinien weitestgehend 

betriebssystemunabhängig zu konfigurieren sind. 

Netzwerkkonstellation *) Standard-Laufzeit 

Einzelplatzsystem 

Visualisierung und Kommunikationskomponente 

laufen auf dem gleichen Rechner 

Verbindung zur SPS 

Kommunikation über ein 

Netzwerk 

Visualisierung verbindet sich über ein Netzwerk mit 

der Kommunikationskomponente 

Verbindung zur 

Kommunikationskomponente 

Visualisierung als OPC-Server 

Visualisierung verbindet sich über ein Netzwerk mit 

einer anderen Visualisierung, die als OPC-Server 

fungiert 

Verbindung zur 

Visualisierung über OPC 



(Windows XP) 



• VisiWinNET- 

Treiber 




• VisiWinNET- 

Treiber 

Compact-Laufzeit 

(Windows CE) 


• VisiWinNET-Treiber 

- 

-



*) Visualisierungen als Client-Server-Projekte werden hier nicht aufgeführt. Sie beinhalten 

die Netzwerkverbindung nicht zwischen Variablenkern und Netzwerkverbindung, sondern 

zwischen Visualisierungsoberfläche und Variablenkern. Natürlich kann diese zusätzliche 

Netzwerkfähigkeit mit den oben aufgeführten Möglichkeiten kombiniert werden. 

4.1.2.3 Projektierunterstützung 

Schon während der Erstellung eines SPS-Programmes muss in der Visualisierung eine 

Auswahl der verwendeten Prozessgrößen vorgenommen werden. 

Dabei müssen Informationen über Datentyp, Zugriff und Adresse jeder Prozessgröße in die 

Projektdatenbank der Visualisierung angegeben werden. Viele SPS- 

Programmierumgebungen generieren eine Liste von Prozessvariablen, deren Übernahme 

über einen Auswahldialog die Arbeit des Visualisierungsprojekteurs erleichtert. Auch hier 

sind Unterschiede für die möglichen Kommunikationskomponenten zu nennen: 

• VisiWin-Treiber beinhalten keine Übernahmeschnittstelle. Hier müssen die 

Informationen für jede Prozessgröße manuell in die Projektdatenbank eingegeben 

werden. 

• Die OPC-Spezifikation beinhaltet das "Browser"-Interface. Hier können die 

Variablendefinitionen über einen Auswahldialog in das Visualisierungsprojekt 

übernommen werden. Anzumerken hierbei ist jedoch, dass das Browsen teilweise mit 

Randbedingungen verknüpft ist. So erwarten einige OPC-Server beispielsweise beim 

Browsen eine angeschlossene SPS. Bei der Datenübernahme über ein Netzwerk können 

Schwierigkeiten mit der richtigen DCOM-Konfiguration auftreten und schließlich bleibt 

es jedem Hersteller eines OPC-Servers überlassen, ob er das Browsen überhaupt 

unterstützt. 

• Auch VisiWinNET-Treiber beinhalten eine (optionale) Schnittstelle zur einfachen 

Variablenübernahme. Zusätzlich wird hier auch das manuelle Anlegen von Variablen in 

der Projektdatenbank durch einen Dialog vereinfacht, der eine Maske für die 

unterstützten Adressen und Datentypen der SPS beinhaltet. 

4.1.2.4 Visualisierungsunabhängigkeit 

Wird eine möglichst hohe Unabhängigkeit angestrebt, weil z.B. sowohl die SPS als auch die 

Programmteile der Visualisierung austauschbare Elemente eines Gesamtkonzeptes sein 

sollen, sind folgende Unterschiede zu nennen: 

Sowohl VisiWin- als auch VisiWinNET-Treiber sind kommunikationstechnisch fest mit den 

Visualisierungssystemen der VisiWin-Familie verknüpft. OPC ist ein verbreiteter Standard, 

der von den Applikationen, die mit der SPS Daten austauschen nur die Implementierung 

einer OPC-Client-Schnittstelle erwarten. Soll also beispielsweise ein optionales 

Datenerfassungssystem SPS-Werte speichern, kann es dies gegebenenfalls direkt über einen 

OPC-Server erledigen, ohne dabei andere Applikationsteile, wie z.B. die Visualisierung, zu 

verwenden. 

In der Praxis zwingen aber nur sehr wenige Gründe den Projekteur, einen OPC-Server zu 

verwenden. Insbesondere sei darauf verwiesen, dass auch die Visualisierung selbst die über 

einen VisiWin-Treiber bezogenen Daten als OPC-Server für andere Anwendungen zur 

Verfügung stellt. Eine Anbindung weiterer Applikationen über OPC ist also nicht unbedingt 

ein K.O.-Kriterium für VisiWin-Treiber.



4.1.2.5 Optimierungen 

Die in VisiWinNET implementierten Optimierungsverfahren reduzieren mithilfe von zwei 

Mechanismen die Anzahl der Anfragen und damit das auszutauschende Datenvolumen: 

• Über Gruppen kann der Austausch von Variablenwerten blockweise oder einzeln 

gesteuert werden. Dabei kann entschieden werden, ob die Variablen synchron oder 

asynchron abgefragt werden und in welchem Zyklus die Abfrage bei der Steuerung 

erfolgt. Die Abfrage kann gezielt für eine Gruppe gestartet oder gestoppt werden, so 

dass beispielsweise die Visualisierung erst dann Variablen mit der SPS austauscht, wenn 

diese für die aktuelle Applikationsseite relevant sind. 

• Strukturen und Felder reduzieren die Übertragung des Protokollrahmens und die Anzahl 

der Anfragen bei der SPS. Felder fragen dabei einen Block von Variablen gleichen Typs 

ab. Strukturen beinhalten die Übertragung von Variablen unterschiedlicher Datentypen. 

Um auf erträgliche Übertragungszeiten zu kommen, müssen diese beiden 

Optimierungsverfahren bei bestimmten Kommunikationskomponenten eingesetzt 

werden. 

Beispiel: 

Die Übertragung von 100 Datenworten über einen den VisiWin-Treiber "S7 MPI" (RS 485-Schnittstelle) dauert ca. 2s, 

wenn jedes einzelne Datenwort als Variable in VisiWinNET definiert wurde. Liegen die Datenworte in der SPS in einem 

zusammenhängenden Speicherbereich, können die Variablen als Feld oder als Struktur definiert innerhalb von ca. 100 

ms abgefragt werden. 

Konzeptionell hat der Treiber und damit das System durch die Definition als 

Variablenfeld an zwei Stellen Zeit gewonnen: 

• Die Anfrage beinhaltet nur einmalig das Rahmenprotokoll, die Adresse sowie die Länge 

des abzufragenden Datenblockes. Weitere Rahmenprotokolle müssen nicht übertragen 

werden. 

• Die Wartezeit zwischen Anfrage, Antwort und erneuter Abfrage entfällt. 

Die Gruppensteuerung wird von VisiWinNET-Treibern und OPC-Servern auf jeden Fall 

unterstützt. Einschränkungen gelten hier für VisiWin-Treiber: Das synchrone Lesen wird 

erst ausgeführt, wenn alle Schreibaufträge ausgeführt wurden. 

Bei OPC-Servern ist zu überprüfen, ob der Zugriff über Felder oder Strukturen möglich 

ist. Dazu müssen Datenblöcke entweder als Startadresse eines Byteblockes oder über 

IEC1131 zu adressieren sein. 

VisiWin(NET)-Treiber gewährleisten diesen Zugriff in den Standard-Projekttypen.



4.1.2.6 Datenkonsistenz 

Ein typisches Beispiel fehlerhafter Datenkonsistenz ist das Setzen eines Trigger, der in 

der SPS eine Aktion startet und dort auch automatisch zurückgesetzt wird. In der Praxis 

führt dies oftmals zum Fehler in der Anzeige und zu der Vermutung, dass 

Wertänderungen von der Visualisierung "verschluckt" werden. 

Beispiel "verlorener" Werte: 

Aktionen (in chronologischer 

Reihenfolge) 

Bitwert 

Steuer- 

element 

Variablen 

- 

kern 

OPC- 

Server 

(Lese- 

Cache) 

OPC- 

Server 

(Schreib- 

puffer) 

Ausgangszustand 0 0 0 - 0 

Bediener setzt Bit 1 0 0 - 0 

Anforderung wird 

weitergereicht an 

Variablenkern 

Anforderung wird 

weitergereicht an OPC-Server 

OPC-Server reicht 

Anforderung im Schreibcache 

an SPS weiter 

SPS verarbeitet die Aktion 

und setzt den Wert zurück auf 

0 

. 

. 

. 

Endzustand: Beim nächsten 

Lesen vergleicht der OPC- 

Server den gelesenen Wert 

mit dem Wert im Lesecache, 

stellt fest, dass keine 

Änderung vorgenommen 

wurde und gibt keine 

weiteren Nachrichten an den 

Variablenkern ab. 

1 1 0 - 0 

1 1 0 1 0 

1 1 0 1 1 

1 1 0 - 0 

1 1 0 - 0 

Der hier gezeigte Ablauf entspricht genau der OPC-Spezifikation mit der Anforderung eines 

getrennten Schreib- und Lesepuffers. Tatsächlich ist es so, dass eine Menge Supportfälle von 

der INOSOFT bearbeitet werden, die genau dieses völlig unerwünschte Verhalten zeigen. 

SPS


Abhilfen: 


• Der Hersteller eines OPC-Servers kann gegen die Spezifikation verstoßen und eine 

Verbindung zwischen Schreib- und Lesecache einbauen, d.h. er müsste den geänderten 

Wert nach dem Versenden in den Lesecache übertragen. Allerdings sind solche 

Informationen üblicherweise nicht aus dem Datenblatt zu ersehen und müssen ggf. 

genau mit dem Hersteller abgesprochen sein. 

• Eine andere Möglichkeit besteht darin, genau diese Konstellationen des beidseitigen 

Schreibens auf eine Variable zu vermeiden. Möglicherweise hilft ein inkrementierender 

Zähler, der als Trigger an die SPS übersendet wird. Eine Quittierung der SPS über Start 

oder Ende einer Aktion sollte auf einer anderen Variablen zurückgegeben werden. 

Letztlich erkauft man sich so eine Datenkonsistenz durch erhöhten Programmieraufwand 

in SPS und Visualisierung. 

VisiWin-Treiber beinhalten übrigens diese Verbindung zwischen Lese- und Schreibcache. 

Werte, die geschrieben wurde, werden auch gleich in den Lesecache übertragen und dort als 

geändert markiert. 

Auch VisiWinNET-Treiber beinhalten diese Rückmeldung des geschriebenen Wertes. 

Hier wird der geschriebene Wert in etwaig anstehende Rückmeldungen von 

Lesezugriffen gepatcht.


4.2 Prozessvariable 

Definitionen der Prozessanbindung / Prozessvariable / Kommunikationskomponenten 25 

Prozessvariablen repräsentieren in der Visualisierung Prozessdaten (Werte, die von der SPS 

als Speicherzellen zur Verfügung gestellt werden). Dabei sind als wichtigste Informationen 

die Adresse (ItemID) und die Repräsentationsform (Datentyp) des angesprochenen SPS- 

Speicherbereiches in der Prozessvariablendefinition enthalten. 

Zusätzlich zur reinen Übertragung von Prozessdaten unterstützt eine 

Prozessvariablendefinition in VisiWinNET u.a. folgende Sonderfunktionen: 

• Angabe von Grenzwerten (Maximal-/Minimalwert), die die Itemqualität beeinflussen 

können 

• Angabe eines Ersatzwertes 

• Zugriff auf Datenfelder 

• Zugriff auf Strukturen 

• Sprach-/Prozessvariablenwertabhängige Umrechnung von Prozessvariablenwerten 

(Einheitenklassen) 

Parameter der Prozessvariablendefinition 


Adresse Bezeichner der Prozessvariablen aus der 

Kommunikationskomponente (für VisiWin-Treiber). 

Alias Bezeichner des Objektes. 

Datentyp Bestimmt den Aufbau und die Länge des Prozessvariablenwertes. 



(Anzeige) 


(Prozess) 

Verweis auf eine sprach- oder variablenabhängige Umrechnung. 

Verweis auf eine variablenabhängige Umrechnung. 

Einzeln beschreibbar Legt fest, ob die Elemente einer Prozessvariablen eines komplexen 

Datentyps einzeln zur Kommunikationskomponente geschrieben 

werden können. 

Ersatzwert Wert, der anstelle des wahren Prozesswertes weitergereicht wird. 

Ersatzwert Modus Legt fest, wann der Ersatzwert weitergereicht wird. 

Feldgröße Anzahl der Prozessvariablen bei blockweisem Zugriff. 

ItemID Bezeichner der Prozessvariablen aus der 

Kommunikationskomponente (für OPC-Server). 

Kommentar Wahlfreier Kommentar zum Objekt.


Definitionen der Prozessanbindung / Prozessvariable / Prozessvariablen bearbeiten 26 

Maximalwert Oberer Grenzwert, den die Prozessvariable annehmen darf. 

Minimalwert Unterer Grenzwert, den die Prozessvariable annehmen darf. 

Text Sprachumschaltbarer Text zur Prozessvariablen 

Variablenoptionen Bitcodierte Einstellungen zur Prozessvariablen 

Zugriffsart Lese-/Schreibrechte auf die Prozessvariable. 

Zugriffspfad Optionale hardwarespezifische Datenwegbeschreibung für die SPS. 

4.2.1 Prozessvariablen bearbeiten 

Prozessvariablen werden in Kommunikationskanälen projektiert und im Tabelleneditor 

angezeigt. Jede Prozessvariablen beinhaltet einen editierbaren Parametersatz: Hier werden 

der Name, die Quelle in der Steuerung und weitere Funktionen eingestellt. 

Der Tabelleneditor der Prozessanbindung wird über einen Klick auf einen entsprechenden 

Knoten im Projektexplorer geöffnet. 

Neben der flachen Darstellung (alle Prozessvariablen werden als eine Liste aufgezeigt) 

beinhaltet der Editor die Strukturierung in Namensräumen. Dabei werden die 

Prozessvariablenbezeichner durch ein Separatorzeichen zerlegt. Aus den einzelnen 

Namensbestandteilen werden Strukturierungsknoten gebildet, die im Projektexplorer als 

Navigationshilfe angezeigt werden. Das Separatorzeichen kann vom Projekteur als 

Parameter des Kommunikationskanals geändert werden. 

Der Editor bietet folgende Funktionen zum Projektieren von Prozessvariablen: 

Neu erzeugen Über Eintrag "Neu" im Kontextmenü des Tabelleneditors wird eine 

neue Prozessvariablen in das Projekt eingefügt. Dieses manuelle 

hinzufügen von Prozessvariablen wird üblicherweise verwendet: 

• Wenn interne Prozessvariablen definiert werden. 

• Wenn Prozessvariablen in VisiWin-Treibern definiert werden 

müssen 

• Wenn der OPC-Server oder VisiWinNET-Treiber nicht über 

eine Browse-Schnittstelle verfügt 

Alternativ zum manuellen Hinzufügen können Prozessvariablen 

auch aus einem bestehenden OPC-Server-Projekt gelesen werden. 

Das Lesen erfolgt über die sogenannte Browse-Schnittstelle 

(Bestandteil der OPC-Spezifikation oder spezielle Komponente für 

einen VisiWinNET-Treiber). In einem Variablenauswahldialog 

werden dabei die dem OPC-Server bekannten Variablen des 

Steuerungsprogramms aufgelistet. Von hier aus können 

Prozessvariablen direkt in das Projekt übernommen werden. Der 

Browse-Dialog wird (wenn von der Kommunikationskomponente 

unterstützt) aus dem Kontextmenü des Kanalknotens im 

Projektexplorer aufgerufen.


Parameter 

bearbeiten 

Definitionen der Prozessanbindung / Prozessvariable / Prozessvariablen bearbeiten 27 

Die VisiWinNET-Eigenschaftenseite zeigt die Parameter der im 

Tabelleneditor markierten Prozessvariablendefinition an. Das 

Bearbeiten der Parameter ist aber auch direkt in den Feldern des 

Tabelleneditors erlaubt. 

Löschen Eine oder mehrere Prozessvariablen können gelöscht werden, 

indem: 

• zuerst die zu löschenden Definitionen markiert werden (Klick 

auf die Selektorspalte am linken Tabellenrand ggf. bei 

gehaltener Strg- oder Shift-Taste für eine Mehrfachselektion) 


"Löschen" gewählt wird. 

Prozessvariablen werden über den gleichnamigen Parameter einer Gruppe zugeordnet. 

Die Gruppendefinitionen des Projektes werden im Projektexplorer angezeigt. Sie 

beinhalten Informationen, die den Datenaustausch mit der Kommunikationskomponente 

steuern. Im Tabelleneditor werden nach dem Markieren eines Gruppenknotens die 

zugeordneten Prozessvariablen dargestellt. In dieser Darstellung können 

Prozessvariablen bearbeitet, jedoch nicht gelöscht oder neu eingefügt werden.


4.3 Gruppe 

Definitionen der Prozessanbindung / Gruppe / Prozessvariablen bearbeiten 28 

Gruppendefinitionen dienen zur Steuerung des Datenaustausches: Prozessvariablen aus 

verschiedenen Kommunikationskanälen können einer Gruppe zugeordnet werden. Die 

Gruppendefinition enthält die Information, in welchem Zyklus oder auf welches Ereignis die 

Prozessvariablenwerte zwischen Variablenkern und Kommunikationskomponente 

ausgetauscht werden. 

Damit der Datenaustausch überhaupt funktioniert, muss jede 

Prozessvariable in einer Gruppe vorhanden sein. Daher werden 

automatisch alle in ein VisiWinNET-Projekt neu eingefügte 

Prozessvariablen in die Gruppe "Standard" eingetragen. 

Gruppen stellen folgende Funktionalitäten zur Verfügung: 

• synchroner oder asynchroner Datenaustausch einzeln für Lese- und Schreibzugriffe 

einstellbar. 

• Prozessvariablenwert-gesteuerte Aktivierung des Datenaustausches aller 

Prozessvariablen über eine Steuervariable. 

Parameter des Gruppenobjektes 


Abtastzeit Zykluszeit des Datenaustausches 

Definition aktiv Bestimmt, ob zur Laufzeit die Definition gültig ist. 

Aktivierungsmodus Datenaustausch automatisch oder Variablenwert-gesteuert 

Hysterese Änderungsgrad von Prozessvariablenwerten, bei dem ein 

Leszugriff ausgelöst wird. 


Lesezugriffe synchroner oder asynchroner Datenaustausch für lesende Zugriffe 


Schreibzugriffe synchroner oder asynchroner Datenaustausch für schreibende 

Zugriffe 

Steuerobjekt in Abhängigkeit vom Aktivierungsmodus gewähltes Objekt zum 

Steuern der Gruppenfunktionalität 

Zeitzonendifferenz Korrektur der Prozessvariablen-Zeitstempel bei Überschreiten 

einer Zeitzonengrenze


Definitionen der Prozessanbindung / Gruppe / Gruppen bearbeiten 29 

4.3.1 Gruppen bearbeiten 

Gruppen werden im Projektexplorer unter dem Knoten "Kommunikation→Gruppierungen" 

dargestellt. Jede Gruppe beinhaltet: 

• einen editierbaren Parametersatz: Hier kann der Name oder beispielsweise die 

Abtastzeit eingestellt werden. 

• ggf. Verknüpfungen zu Prozessvariablendefinitionen: Prozessvariablen werden über den 

gleichnamigen Parameter einer Gruppe zugeordnet. Im Tabelleneditor werden nach dem 

Markieren eines Gruppenknotens die zugeordneten Prozessvariablen dargestellt. 

Der Editor bietet folgende Funktionen zum Projektieren von Gruppen: 

Neu erzeugen Über Eintrag "Neu" im Kontextmenü des Knotens "Gruppierungen". 

Parameter 

bearbeiten 

Ein Klick auf einen Gruppenknoten lädt die entsprechenden 

Parameter in die VisiWinNET-Eigenschaftenseite. Hier können die 

Parameterwerte der Gruppendefinition bearbeitet werden. 

Löschen Über den Eintrag "Löschen" im Kontextmenü eines 

Gruppenknotens wird die Definition gelöscht. Dabei werden alle 

Verknüpfungen zu Prozessvariablen zurückgelenkt auf die Gruppe 

"Standard". 

Damit der Datenaustausch überhaupt funktioniert, muss jede 

Prozessvariable in einer Gruppe vorhanden sein. Daher werden 

automatisch alle in ein VisiWinNET-Projekt neu eingefügte 

Prozessvariablen in die Gruppe "Standard" eingetragen. 

4.3.2 Verwendung von Gruppen 

Nicht alle Kommunikationskomponenten der Firma INOSOFT 

unterstützen die hier genannten Funktionen vollständig. Lesen Sie 

bitte auch die spezifische Dokumentation der entsprechenden 

Treiber/ OPC-Server. 

Bei OPC-Servern von Fremdherstellern lesen Sie die einschlägige 

Dokumentation bzw. nehmen Sie Rücksprache mit dem Hersteller. 

Das natürliche Verhalten freilaufender Prozessvariablen in VisiWinNET schließt ein, dass 

jede Variable einer Gruppe zugeordnet ist. Über die Gruppe wird festgelegt, wann bzw. in 

welchem Abtastzyklus die zugeordneten Prozessvariablen zwischen Variablenkern und 

Kommunikationskomponente ausgetauscht werden sollen.


Definitionen der Prozessanbindung / Gruppe / Verwendung von Gruppen 30 

Implizit kategorisiert der Projekteur die Variablen durch die Zuordnung zu Gruppen mit 

unterschiedlichen Einstellungen nach Verwendung und Wichtigkeit. Dabei stehen in der 

Praxis folgende Fragen im Raum: 

• Wann wird eine Variable gebraucht? 

• Welche Latenzzeit ist maximal zulässig (Wie lange darf der Prozessvariablenwert in der 

Oberfläche falsch angezeigt bleiben, wenn sich der Originalwert in der SPS ändert)? 

• Welche Änderungsrate erwarte ich für einen Wert. (sich minütlich ändernder 

Temperaturwert gegenüber Lichtschranke, durch die im 100 ms-Raster ein produziertes 

Teil fährt)? 

Nach dem Anlegen einer neuen Prozessvariablen wird durch die Entwicklungsumgebung 

automatisch die Zuordnung zur Gruppe "Standard" hergestellt. 

Diese Gruppe ist eine Definition aus dem Zweig "Variablen→Gruppierungen". Sie beinhaltet 

die Zykluszeit "250 ms" und ist als "automatisch aktiv" angegeben. Damit wird die Gruppe 

aktiviert, sobald eine darin enthaltene Variable (z.B. durch das Laden eines 

Applikationsformulars) beim Variablenkern angefordert wird. 

Die Parameter einer Gruppendefinition lassen im wesentlichen drei Einstellungen zur 

Kommunikationssteuerung zu: 

Zyklus Legt fest, in welchem Zyklus die Daten von der 

Kommunikationskomponente zurückgegeben werden sollen. 

In der Praxis werden Variablen, deren Änderungsrate langsam ist, 

gemeinsam in eine Gruppe mit einer langsamen Zykluszeit 

gepackt. Dies entlastet die Kommunikation. Es macht keinen Sinn, 

einen Sensorwert im Millisekundentakt abzutasten, wenn eine 

Wertänderung physikalisch maximal alle 10 Sekunden erfolgen 

kann.


automatisch/ 

getriggert 


Abhängig von der verwendeten Kommunikationskomponente hat 

die Zykluszeit folgende Funktion: 

• OPC-Server: Laut OPC-Spezifikation gibt die Zykluszeit an, in 

welchem Takt die Wertänderungen der Variablen einer Gruppe 

an den Client (hier der Variablenkern der Visualisierung) 

zurückgegeben werden. 

• VisiWin-Treiber: Der Variablenkern aktiviert im in der Gruppe 

angegebenen Zyklus eine Neuanforderung auf die enthaltenen 

Variablen. Dabei ist zu beachten, dass der Variablenkern selber 

einen Grundzyklus enthält. Dieser Grundzyklus (einstellbar im 

Projektexplorerknoten "Projektkonfiguration→Laufzeit", 

Einstellung "Zykluszeit") steht in einem neuen Projekt auf 100 

ms. Er bildet das Basisraster für mögliche Anforderungen an 

VisiWin-Treiber. Wird z.B. eine Gruppenzykluszeit kleiner 

eingestellt, als der Zyklus des Variablenkerns ist, hat dies 

keinen Effekt. 

• VisiWinNET-Treiber: Gruppen- und Variablendefinitionen 

werden vom Variablenkern zum Treiber übergeben. Der 

Treiber organisiert selbstständig seine Leseanforderungen in 

den in den Gruppen angegebenen Zyklen. Gelesene Daten 

werden dem Variablenkern zur Verfügung gestellt, der in 

seinem eigenen Zyklus die Daten weiterverteilt. 

Müssen Variablen immer zur Verfügung stehen? 

Typische Anwendungen für Variablen, die der Visualisierung 

während der gesamten Laufzeit zur Verfügung stehen müssen, 

sind: 

• Variablen, die Alarme signalisieren 

• Kontinuierlich aufgezeichnete oder überwachte Werte (Trend, 

Prozessdatenüberwachung) 

• Variablen, die immer (also auf allen Bildschirmseiten) sichtbar 

sind 

Daneben gibt es eine Reihe von Variablen, die nicht immer 

ausgetauscht werden müssen, wie z.B.: 

• Variablen, die nur auf einer Applikationsseite in der 

Visualisierung erscheinen (z.B. Serviceseite) 

• Getriggerte Aufzeichnungen 

• Rezepte 

Die Variablen, die nicht kontinuierlich benötigt werden, lassen sich 

in Gruppen anordnen, die durch einen Trigger aktiviert werden. 

Der Trigger lässt dabei zwei Möglichkeiten zu: 

• Das Ein-/Ausschalten des zyklischen Zugriffs 

• Das Einmalige Lesen/ Schreiben



Über den Trigger lässt sich der Austausch von Variablen einer 

Gruppe also gezielt steuern. So können z.B. die Variablen eines 

Formulars oder eines Rezeptes in einer Gruppe zusammengefasst 

werden. Über die Ansteuerung des Triggers wird aus der 

Applikation heraus die Gruppe erst aktiviert, wenn die 

entsprechende Funktion in der Visualisierung benötigt wird. 

Implizit enthält das System zwei weitere Mechanismen, die sich 

teilweise mit der Funktion der Gruppenaktivierung überschneiden: 

• In der Standard-Laufzeit werden grundsätzlich auch Variablen 

einzeln aktiviert/deaktiviert. Wird ein neues Formular geladen, 

melden sich die Steuerelemente einzeln mit ihren 

Variablenanforderungen beim Variablenkern an. Die OPC- 

Spezifikation beinhaltet zusätzlich zur Gruppenaktivierung 

auch eine Variablenaktivierung. Der Variablenkern der 

Standard-Laufzeit verwendet diese Funktion, wenn eine 

Prozessvariable von der Applikation angefordert wird. So 

können z.B. Variablen aus mehreren Formularen einer Gruppe 

zugeordnet sein und trotzdem werden nur die in den 

geladenen Formularen angegebenen Variablen über die 

Kommunikationskomponente ausgetauscht. 

Die Compact-Laufzeit arbeitet bei OPC-Servern nicht mit der 

Aktivierung auf Variablenebene. Hier wird die Aktivierung nur 

auf Gruppenebene gesteuert, d.h. wird eine Variable 

angefordert, werden alle in der Gruppe enthaltenen Variablen 

über den OPC-Server ausgetauscht.. 

• Ab der Version 6.2 unterstützt VisiWinNET eine optimierte 

Form der Aktivierung einzelner Variablen. Bisher konnte es 

passieren, dass durch die Aktivierung einzelner Variablen in 

bestimmten Kommunikationskomponenten immer wieder 

zeitaufwändige Aufgaben zur Optimierung des Datentranfers 

durchgeführt wurden. Z.B. versuchen verschiedene 

VisiWinNET-Treiber, die zum Datenaustausch angeforderten 

Variablen zu Blöcken zusammenzufassen, die einen geringeren 

Protokollaufwand verursachen. Bei jeder Variablenan- 

/abmeldung werden diese Blöcke neu berechnet. Schicken 

beispielsweise die Steuerelemente eines Formulars 

nacheinander mehrere neue Variablenanforderungen an den 

Variablenkern, werden die entsprechenden Variablen in der 

Kommunikationskomponente einzeln aktiviert. Damit werden 

in der Kommunikationskomponente auch immer wieder die 

gleichen Optimierungsroutinen ausgeführt. 

Abhilfe schafft hier die blockweise Variablenaktivierung, die 

z.B. in 'BaseForm' verwendet wird. Dabei werden die 

Optimierungsmechanismen in der 

Kommunikationskomponente solange unterdrückt, bis alle 

Variablenaktivierungen, die durch das Laden oder Aktivieren 

des Formulars verursacht wurden, beim Variablenkern und 

damit bei der Kommunikationskomponente angekommen sind.



In der Standard-Laufzeit funktioniert dieser Mechanismus auch 

mit OPC-Servern. 

synchron/asynchron Wann ist es sinnvoll, Daten direkt ohne Wartezeiten mit der SPS 

auszutauschen? 

Grundsätzlich gilt: 

• Beim asynchronen Datenaustausch gibt der Variablenkern 

einen Auftrag. Wann die Kommunikationskomponente diesen 

Auftrag ausführt, bleibt ihr selbst überlassen. Das Ergebnis des 

Auftrages (beim Lesen der zurückgelesene Wert, beim 

Schreiben ggf. eine Quittierung) stellt die 

Kommunikationskomponente nach der Bearbeitung entweder 

ereignisgesteuert oder in Form einer gemeinsam genutzten 

Variablenliste zur Verfügung. 

• Beim synchronen Datenaustausch schickt der Variablenkern 

die Datenanforderung ab und wartet solange, bis das Ergebnis 

eintrifft. Um die Wartezeiten kurz zu halten, werden synchrone 

Aufträge von VisiWin- und VisiWinNET-Treibern bearbeitet, 

sobald der aktuell anstehende asynchrone Auftrag beendet 

wurde. Nachfolgende asynchrone Aufträge werden erst wieder 

bearbeitet, sobald keine synchronen Aufträge mehr anstehen. 

Beim Anlegen einer neuen Gruppe wird VisiWinNET von der 

Entwicklungsumgebung das asynchrone Lesen und das synchrone 

Schreiben als Vorgabewert gewählt. Implizit wird hier davon 

ausgegangen, dass beim sich regelmäßig wiederholenden Lesen 

die Latenzzeit (von der Wertänderung in der SPS bis zur Änderung 

einer Anzeige in der Visualisierung) keine wesentliche Rolle spielt, 

beim Schreiben aber der Wert so schnell wie möglich in die SPS 

gelangen soll. In der Praxis funktioniert dieses System, weil der 

Anteil der Schreibaufträge gegenüber den Leseaufträgen gering 

ist. 

Leitsatz: 

Jeder synchrone Zugriff blockiert den Variablenkern und damit 

auch die Applikation bis zur Abarbeitung. Halten Sie daher 

synchrone Aufrufe so kurz wie möglich und vermeiden Sie den 

regelmäßigen zyklischen Gebrauch. 

In bestimmten Fällen wird ungeachtet der Einstellung 

"synchron/asynchron" vom Variablenkern immer eine synchrone 

Datenübertragung ausgeführt: 

• Beim Lesen und Schreiben von Rezepten 

• Beim Lesen eines Variablenwertes über die Funktion 'VWGet', 

wenn der Übergabeparameter 'avoidCache' den Wert 'true' hat.


FAQ 


• Frage: Meine Kommunikation läuft langsam und stockend, 

warum? 

Antwort: Teilen Sie die Variablen Ihres Projektes in 

verwendungsbezogene Gruppen auf. Wählen Sie dabei 

realistische Zykluszeiten. Aktivieren Sie jeweils zu einem 

Zeitpunkt nur die Gruppen, deren Variablen sie gerade in der 

Visualisierung verwenden. 

• Frage: Gibt es neben Gruppen noch andere 

Optimierungsmöglichkeiten für die Kommunikation? 

Antwort: Neben Gruppen können auch Strukturen einen 

wesentlichen Anteil an der Performanceoptimierung 

einnehmen (siehe Kap. "Verwendung von Strukturen").. 

• Frage: Ich verwende einen VisiWin-Treiber. Nach mehreren 

Versuchen habe ich mein Projekt auf eine einzige Variable 

abgespeckt. Und trotzdem wird die angegebene Zykluszeit von 

50 ms nicht eingehalten. Warum? 

Antwort: Überprüfen Sie in der Projektkonfiguration die 

Zykluszeit des Variablenkerns. Der Wert dafür steht bei einem 

neuen Projekt auf 100ms. ÜBerprüfen sie außerdem die 

Kommunikationszeit des zuletzt kommunizierten Objektes in 

dem Fensteroberfläche des Treibers (Siehe Dokument 

"VisiWin-Treiber"). Ein entsprechender Diagnosedialog ist auch 

in VisiWinNET-Treibern implementiert. 

• Frage: Ich habe einen VisiWinNET-Treiber und zwei Gruppen. 

Der Großteil der Variablen liegt in der Standardgruppe mit 2s 

Zyklus. Einige Variablen aber brauche ich für eine 

Messwertaufnahme im 50 ms-Zyklus. Die habe ich in eine 

Extra-Gruppe mit der entsprechenden Zykluszeit gepackt. Die 

Variablen kommen aber nicht zuverlässig im angegeben 

Zyklus. 

Antwort: Tatsächlich arbeitet der VisiWinNET-Treiber erst alle 

Aufträge einer Gruppe ab. Wenn die Abarbeitungszeit den 

Zyklus einer anderen Gruppe überschreitet, kommt das 

Ergebnis für die Variablen der anderen Gruppe entsprechend 

später. Überlegen Sie, ob Sie die aufgenommenen Messwerte 

in der SPS in einen Felddatentyp (z.B. Feld mit 1000 

Elementen vom Datentyp VT_R4) packen können. Beschreiben 

Sie die Elemente der Variable im SPS-Programm mit den 

aufgenommenen Werten. Lesen Sie in der Visualisierung die 

Feldvariable als Datenblock aus. Für die Darstellung und 

Verwaltung als Messkurve z.B. unterstützt der Client 

Funktionen, über die auch Felder programmatisch in ein 

Trendobjekt übertragen werden können.



• Frage: Ich verwende den OPC-Server "Simatic NET". Trotzdem 

ich alle Prozessvariablen formularweise einzelnen Gruppen 

zugeordnet habe, dauert das Laden der Formulare sehr lange. 

Wie optimiere ich die Ladezeiten der Formulare? 

Antwort: Hier ist das Aktivieren der einzelnen Variablen das 

Problem. Verwenden sie den blockweisen 

Variablenaktivierungsmechanismus durch die Verwendung von 

'BaseForm'.


4.4 Einheitenklasse 

Definitionen der Prozessanbindung / Einheitenklasse / Verwendung von Gruppen 36 

Einheitenklassen ermöglichen die Variablenwert-/ oder sprachabhängige Umrechnung von 

Prozessvariablen durch den Variablenkern. Der Bezug einer Prozessvariablen auf eine 

Einheitenklasse wird dabei durch die Parameter Einheitenklasse (Prozess)/ (Anzeige) 

hergestellt. Die Umrechnung kann zu zwei Zeitpunkten erfolgen. 

• Beim Datenaustausch zwischen Kommunikationskomponente und Variablenkern durch 

eine variablenabhängige Einheitenklasse: Der umgerechnete Wert wird im gesamten 

System als Prozessvariablenwert verteilt. Eine Archivierung z.B. würde nur den 

umgerechneten Wert speichern. 

• Beim Datenaustausch zwischen Variablenkern und Visualisierung durch eine sprach- 

oder eine variablenabhängige Einheitenklasse: Nur die Visualisierung bekommt den 

umgerechneten Wert. Dies ist z.B. sinnvoll bei einer sprachabhängigen 

Einheitenumschaltung (Meter/Inch) insbesondere in einem Client-/Serversystem mit 

mehreren Clients unterschiedlicher Sprache. 

Einheitenklassen beinhalten u.a. folgende Funktionalität: 

• Umschaltung in Abhängigkeit von der aktuellen Spracheinstellung eines Clients. 

• Umschaltung in Abhängigkeit von einer Prozessvariablen. 

Parameter der Einheitenklasse 

Einheitenklasse (variablenabhängig) 


• Eine sprachabhängige Einheitenklasse kann nicht im Parameter 

"Einheitenklasse (Prozess) einer Prozessvariablen verwendet 

werden. 

• Wird eine variablenabhängige Einheitenklasse im Parameter 

"Einheitenklasses (Anzeige) einer Prozessvariablen angegeben, 

ist es in einem Client-Server-System fast immer sinnvoll, die 

Umschaltvariable der Einheitenklasse als "clientintern" zu 

markieren. (Siehe Parameter "Variablenoptionen"). 



Umschaltvariable Variable zum Umschalten zwischen den Einheitenobjekten 

Einheitenklasse (sprachabhängig) 




Standardsprache Legt die zu benutzende Einheit fest, wenn für die aktuelle Sprache 

kein Einheitenobjekt definiert wurde


4.4.1 Einheitenklassen bearbeiten 

Einheitenklassen werden im Projektexplorer unter dem Knoten 

"Kommunikation→Einheitenklassen" in zwei Kategorien unterteilt: 

variablenabhängig Umschaltung über einen Variablenwert 

Definitionen der Prozessanbindung / Einheitenklasse / Einheitenklassen bearbeiten 37 

sprachabhängig Umschaltung über die im Projekt aktive Sprache 

Jede Einheitenklasse beinhaltet: 

• einen editierbaren Parametersatz: Hier kann der Name und die Umschaltung 

parametriert werden. 

• ggf. Verknüpfungen zu Einheitendefinitionen: Im Tabelleneditor werden nach dem 

Markieren einer Einheitenklasse die zugehörigen Einheitenumrechnungen dargestellt. 

Prozessvariablendefinitionen nehmen über die Parameter "Einheitenklasse (Prozess)" und 

"Einheitenklasse (Anzeige)" bezug auf die Einheitenklassendefinitionen. 

Der Editor bietet folgende Funktionen zum Projektieren von Einheitenklassen: 

Neu erzeugen Über Eintrag "Neu" im Kontextmenü der Knoten 

"variablenabhängig" und "sprachabhängig" . 

Parameter 

bearbeiten 

Ein Klick auf eine Einheitenklasse lädt die entsprechenden 


Parameterwerte bearbeitet werden. 


Einheitenklassenknotens wird die Definition gelöscht. Dabei 

werden auch die enthaltenen Einheitenumrechnungen gelöscht.


Definitionen der Prozessanbindung / Einheitenklasse / Einheitenumschaltungen implementieren 38 

4.4.2 Einheitenumschaltungen implementieren 

Einheitenumschaltungen basieren in VisiWinNET auf Umrechnungen von 

Prozessvariablenwerten anhand linearer Gleichungen. Ein typisches Beispiel hierfür ist die 

physikalische Größe "Temperatur", die länderspezifisch im europäischen Raum über die 

Einheit "Celsius" angegeben, im amerikanischen Raume jedoch über "Fahrenheit" dargestellt 

wird. 

Umrechnung physikalischer Größen 

Die Umrechnung der Größe "Temperatur" von "Celsius" auf "Fahrenheit" erfolgt nach 

folgender Formel: 

°C = (°F - 32) / 1,8 

oder umgekehrt: 

°F = °C × 1,8 + 32 

In VisiWinNET wird diese lineare Gleichung über zwei Punkte eines linearen Kurvenverlaufs 

angegeben. Dazu werden die Werte von zwei berechneten Punkten in einer 

Einheitendefinition angegeben. Ausgehend von der Größe °C sieht die Rechnung 

exemplarisch wie folgt aus: 

Für 0 °C ergibt sich: 0 x 1,8 +32 = 32 (°F) 

Für 100 °C ergibt sich 100 x 1,8 + 32 = 212 (°F) 

Anzugeben sind dann als X-Koordinaten die Werte der Berechnungs-Ausgangsgröße, hier als 

0 und 100. Als Y-Koordinaten werden die jeweiligen berechneten Werte angegeben, hier 

also 32 und 212. 

In der Entwicklungsumgebung sieht die Eingabe der berechneten Daten dann so aus: 

Im oben dargestellten Bild sind zwei Einheitenumrechnungen definiert. Für "German" wird 

der Wert quasi nicht beeinflusst, da die X/Y-Wertepaare identisch sind. 

Der Verlauf der linearen Gleichung über die beiden Koordinaten (0:0) und (1:1) ergibt eine 

Gerade, die mit der Steigung 1 durch den Nullpunkt geht, d.h. X und Y sind für alle Punkte 

der Geraden identisch. 

In der "English"-Umrechnung sind die oben berechneten Werte in die entsprechenden 

Parameterfelder eingegeben worden. 

Dieses Beispiel funktioniert aber nur, wenn die umzurechnenden Prozessvariablen direkt 

den Temperaturwert als °C zurückgeben. Ist das nicht der Fall, muss die spezifische 

Sensorauflösung über eine Sensoranpassung in die Berechnung einbezogen werden.


Sensoranpassungen 


Beispiel: Eine von der SPS aufgenommene Strecke von 0..1000 mm soll in der Applikation 

dargestellt werden. Dabei stehen zwei verschiedene Sensortypen mit folgenden 

Ausgabebereichen zur Verfügung 

Typ Messbereich Ausgabewertebereich 

A 0..2000 mm 0..32000 

B 0.. 100 inch 0..32000 

Die Umrechnung für mm in inch lautet: 

1 in. = 25,4 mm 

Die zu erwartenden Wertebereiche für die Strecke 0..1000 mm sind also für: 

• Typ A: 0..16000 (1000/2000 =x/32000) 

• Typ B: 0..12599 (1000/100*25,4 = x/32000) 

Die beiden Sensoren haben also unterschiedliche Wertebereiche. Eine Anpassung in der 

Visualisierung kann über eine variablenabhängige Einheitenklasse realisiert werden. Die 

Umrechnung soll dabei zwischen Kommunikationskomponente und Variablenkern erfolgen, 

so dass im Variablenkern ein sensorunabhängiger Messwert zur Verfügung gestellt wird. 

Die entsprechende Einheitenbeschreibung sieht in der Entwicklungsumgebung so aus: 

Wieder wird für einen Zustand quasi keine Umrechnung angegeben, weil die X- und Y- 

Wertepaare gleich sind. Die zweite Umschaltung enthält die oben berechneten Werte. 

Auf diesem Weg können sensorspezifische Werteanpassungen realisiert werden. 

Merke: Hier geht es erst einmal nur darum, die SPS-Werte für die 

unterschiedlichen Sensoren im Variablenkern anzugleichen, so 

dass es für die weitere Behandlung egal ist, welcher Sensor 

angeschlossen ist. Eine sprachumgeschaltete Umrechnung ist hier 

noch nicht realisiert. Über eine zusätzliche Umrechnung kann dann 

die länderspezifische Umschaltung zwischen "mm" und "inch" für 

die Applikation erfolgen.


Umschaltung von Einheiten 


In VisiWinNET werden die projektierten Einheitenumrechnungen zu sogenannten 

"Einheitenklassen" zusammengefasst. Eine Einheitenklasse beinhaltet mehrere 

Umrechnungen und einen Schalter, der eine der enthaltenen Umrechnungen aktiviert. 

• Bei sprachabhängigen Einheitenklassen ist der Schalter die im Projekt aktive Sprache. 

Jede enthaltene Einheitenumrechnung wird einer Sprache zugeordnet. Durch die 

Umschaltung der Sprache zur Laufzeit wird automatisch zur entsprechenden 

Einheitenrechnung gewechselt. 

• Variablenabhängige Einheitenklassen beinhalten als Schalter eine Prozessvariable. Hier 

beinhaltet jede Einheitenumrechnung den Parameter "Umschaltzustand" der zur Laufzeit 

mit dem Wert der als "Schalter" angegebenen Prozessvariablen verglichen wird. Im 

obigen Beispiel der Sensoranpassung liegt die Umschaltvariable üblicherweise als 

interne Variable vor, die beim Einrichten der Visualisierung auf den entsprechenden 

Wert für den verwendeten Sensor konfiguriert wird. 

Funktionale Verknüpfung 

In VisiWinNET werden die Prozessvariablendefinitionen direkt mit Einheitenklassen 

verknüpft. Implizit wird hier davon ausgegangen, dass schon die Definition einer 

Prozessvariablen das Merkmal einer physikalischen Einheit mit einschließen sollte. Gibt die 

Prozessvariable beispielsweise einen Temperaturwert wieder, kann die physikalische Größe 

mit Einheitentext und länderspezifische Umrechnungsformel direkt bei der Definition der 

Variablen angegeben werden. 

Dies hat den Vorteil, dass bei der Darstellung der Prozessvariablen, sei es als Wertausgabe, 

als Trendaufzeichnung oder als Bestandteil eines Reports jedes mal die 

Einheiteninformationen ohne weiteren Projektieraufwand als Bestandteil der Variable mit 

einbezogen werden.



Die Angabe der zu verwendenden Einheitenklassen erfolgt in der Variablendefinition in den 

Parametern "Einheitenklasse (Prozess)" und "Einheitenklasse (Anzeige)":. 

• Die Einheitenklasse (Prozess) gibt die Berechnungsformeln an, die bei der Übertragung 

des Variablenwertes zwischen Kommunikationskomponente und Variablenkern 

angewendet werden. Diese Formeln werden üblicherweise verwendet, wenn eine 

Anpassung unterschiedlicher Sensortypen auf einen einheitlichen Wertebereich erfolgen 

soll. Diese Umrechnungsformeln können nur aus Einheitenklassen vom Typ 

"variablenabhängig" bezogen werden. Die Umschaltung zwischen den einzelnen 

Umrechnungsformeln kann also nur über einen Variablenwert erfolgen. 

• Die Einheitenklasse (Anzeige) wird vom System bei der Übertragung des 

Variablenwertes zwischen Variablenkern und Visualisierungsoberfläche angewendet. Sie 

kann sowohl sprachabhängig als auch variablenabhängig sein. Über die Verwendung von 

sprachabhängigen Einheitenklassen wird die typische Umschaltung länderspezifischer 

Einheitenumrechnungen realisiert. Über die Verwendung von variablenabhängigen 

Einheitenklassen als "Einheitenklasse (Anzeige)" können zusätzlich spezifische 

Sonderanforderungen in der Applikationsoberfläche realisiert werden. Soll 

beispielsweise eine Streckenangabe in der Applikation in den Größen "mm", "cm", "inch" 

und "mil." erfolgen, so lässt sich das nicht alleine durch die Umschaltung der Sprache 

realisieren. 

Kommaverschiebung/Nachkommastellen 

Die Funktion des in der Einheitendefinition angegebenen Parameters "Kommaverschiebung" 

ist abhängig vom Datentyp der Prozessvariablen, die die Einheitenklasse verwendet: 

• Für ganzzahlige Prozessvariablen gilt: Mit der Kommaverschiebung kann eine 

Dezimalverschiebung von ganzzahligen Werten realisiert werden. Der Wert 112 wird 

z.B. als "11.2" dargestellt, wenn die Kommaverschiebung mit 1 angegeben wurde. Gibt 

ein ganzzahliger Datentyp aus der SPS beispielsweise eine Temperatur in 100stel Grad 

an, kann über die Kommaverschiebung "2" in der Darstellung das Komma an die richtige 

Stelle geschoben werden. 

• Ist eine Prozessvariable als Fliesskommazahl definiert, gibt die Kommaverschiebung als 

Formatierungsanweisung die Zahl der darzustellenden Nachkommastellen an. 

Für ganzzahlige Variablentypen (VT_I2, VT_I4, ...) gilt: Die Kommaverschiebung ist eine 

gute Lösung, Rundungsfehlern aus dem Weg zu gehen. Intern behandelt das System einen 

ganzzahligen Prozessvariablenwert, der mit einer Einheitenumschaltung verknüpft ist, wie 

einen Fliesskommawert. Beim Lesen des Wertes wird der Wert aus der SPS im Variablenkern 

über die lineare Umrechnung auf eine Fliesskomavariable umgerechnet. Bei der Eingabe des 

Wertes muss diese Konvertierung umgekehrt durchgeführt werden. Wird hier die lineare 

Gleichung verwendet, muss der Wert ggf. gerundet werden. In der Applikation tritt dann in 

ungünstigen Fällen der Fall ein, dass der Bediener einen Wert in ein Steuerelement schreibt 

und nach dem Senden der Wert im Steuerelement auf den nächsthöheren/-niedrigeren Wert 

umspringt Dieses Phänomen tritt bei der alleinigen Verwendung der Kommaverschiebung 

nicht auf.



Die Kommaverschiebung kann für eine Prozessvariable an drei verschiedenen Stellen 

angewendet werden: 

• In der Einheitenklasse (Prozess) 

• In der Einheitenklasse (Anzeige) 

• In einem variablengebundenen Steuerelement (Eigenschaft VWItem.DecPoint) 

Dabei addieren sich die drei Angaben der einzelnen Kommaverschiebungen in der Anzeige. 

Beispiele: 

Angegebene 

Kommaverschiebungen 

Einheiten- 

klasse 

Prozess 

Einheiten- 

klasse 

Anzeige 

Werte in der SPS Angezeigte Werte 

Steuerelement VT_I4 VT_R4 VT_I4 VT_R4 

1 1 1 1234 1,2345 1,234 1,234 

3 0 1 12 12 0,0012 12,0000 

0 0 2 880 0,8 8,8 0,80 

Darstellung 

VarIn/ VarOut Die typische Darstellung eines einheitenbehafteten Wertes 

beinhaltet in den Steuerelementen 'VarIn' und 'VarOut' den 

Einheitentext und den umgerechneten und formatierten Wert. 

Die Steuerelemente beinhalten mehrere Eigenschaften, die die 

Darstellung der Einheitenumschaltung betreffen, die als 

Einheitenklasse (Anzeige) in der verknüpften Prozessvariablen 

angegeben ist: 

• Im oben gezeigten 'VarIn'-Steuerelement wird über die 

Eigenschaft 'VWItem.UnitConversion' bestimmt, ob die 

'Einheitenklasse (Anzeige)' im Steuerelement verwendet 

werden soll. Dadurch werden sowohl die Umrechnungsformel 

als auch die Kommaverschiebung aktiviert. 

• Der in der Einheitendefinition angegebene Einheitentext kann 

über die Eigenschaft 'UseItemUnit' im Steuerelement zur 

Anzeige gebracht und über die Eigenschaft 'Unit' in Aussehen 

und Anzeige parametriert werden. 

• Zusätzlich lassen sich die Nachkommastellen des Wertes über 

die Eigenschaft 'VWItem.DecPoint' formatieren, wenn die 

angebundene Prozessvariable eine Fliesskommazahl darstellt.



Bar/ExtendedSlider In den genannten Steuerelementen ist eine Skala enthalten, über 

die der angebundenen Prozesswert abzulesen ist. Der Bereich der 

Skala und der Wertanzeige wird über die Eigenschaften 'MinValue' 

und 'MaxValue' eingestellt. 

'MinValue' und 'MaxValue' sind dabei Werte die unabhängig von 

der verwendeten Einheitenklasse im Steuerelement angegeben 

werden. Ist die Eigenschaft 'VWItem.UnitConversion' auf 'true' 

eingestellt, nimmt das Steuerelement aber trotzdem eine 

Umrechnung der Skalenwerte vor. 

Die Anzeige eines Einheitentextes kann über die Eigenschaft 

'UseItemUnit' eingestellt werden. Dadurch wird der Einheitentext 

aus der verwendeten Einheitenklasse in der Skala angezeigt. 

Scale Das 'Scale'-Steuerelement hat keine Anbindung an eine 

Prozessvariable und damit auch keine indirekte Verbindung zu 

einer Einheitenklasse. Über die Eigenschaft 'UnitClass' lässt sich 

aber eine direkte Verbindung zu einer Einheitenklasse herstellen, 

die die Skalenwerte entsprechend umrechnet. 

Grenzwertüberprüfung und Einheitenklassen 

Im 'VarIn'-Steuerelement können über Einheitenklassen umgerechnete Prozesswerte vom 

Benutzer eingegeben werden. Die Eingaben sind dabei auf einen Eingabebereich 

einschränkbar. 

• über die Eigenschaften 'LimitMax' und 'LimitMin' werden oberer und unterer Grenzwert 

angegeben. Zusätzlich ist dabei noch die Eigenschaft 'LimitCheck' auf 'true' zu stellen. 

• über die Eigenschaft 'UseItemLimits' werden Max- und MinValue aus der 

Prozessvariablendefinition gelesen (optional können hier die Eingabegrenzen über die 

Parameter "Maximalwert"./"Minimalwert" angegeben werden). 

Bei beiden Möglichkeiten gilt: Als Eingabegrenzwert wird der nicht in der Anzeige 

umgerechnete Grenzwert erwartet. Repräsentiert z.B. ein Variablenwert (Bereich 0..32000) 

eine Strecke von 0..25,4 mm oder 0..1 Inch und soll der Eingabebereich auf 0,5 Inch 

begrenzt werden, so ist als 'LimitMax' der Wert 16000 anzugeben. 

Bei der Umschaltung der Einheitenumrechnung wird auch die Begrenzung des 

Eingabebereiches automatisch berücksichtigt. 

• Bei der Verwendung einer Bildschirmtastatur (Komponente 'TouchKeyboard') werden die 

Grenzwerte in der NumPad-Tastatur (numerische Eingabe) in umgerechneter Form 

angezeigt. 

• Auch die 'PopupInfo'-Komponente unterstützt die Ausgabe der Grenzwerte.


4.4.2.1 Beispiel 


Inhalt Das folgende Beispiel zeigt drei typische Anwendungen für 

Einheitenklassen: 

• Sensoranpassung 

• Sprachumschaltbare Einheitenumschaltung 

• variablenabhängige Einheitenumschaltung in der Anzeige am 

Beispiel mm/cm/Mil/inch 

Szenario Das Szenario beschreibt folgenden Fall: 

Eine von der SPS aufgenommene Strecke von 0..1000 mm soll in 

der Applikation dargestellt werden. Dabei stehen zwei 

verschiedene Sensortypen mit folgenden Ausgabebereichen zur 

Verfügung 

Typ Messbereich Ausgabewertebereich 

A 0..2000 mm 0..32000 

B 0.. 100 inch 0..32000 

In der Applikation soll der einzusetzende Sensor über eine 

variablenabhängige Einheitenklasse umgeschaltet werden können. 

Außerdem ist die landesspezifische Darstellung der Einheit 

(cm/inch) nachzuvollziehen. Hierzu wird eine sprachabhängige 

Einheitenklasse verwendet 

Als Erweiterung soll zusätzlich eine Umschaltung zwischen 

cm/mm/inch/mil gezeigt werden. Die Umschaltung erfolgt über 

eine zweite variablenabhängige Einheitenklasse. 

Als Definitionen werden für das Beispiel benötigt: 

• zwei interne Variablen, die jeweils als Steuervariablen die variablenabhängigen 

Einheitenklassen umschalten 

• die drei oben genannten Einheitenklassen 

• eine externe Variable aus dem Demo-Treiber, die den umzuschaltenden Wert simuliert



Das Blockschaltbild zeigt den systematischen Aufbau des Beispiels: 

Das Design des Beispiels umfasst die einzelnen Ansichten und die Steuerelemente zum 

Umschalten der Einheiten 

Für das Designs werden folgende Elemente benötigt: 

• Vier Eingabeelemente (VarIn), die die einzelnen Stufen der Umrechnungen zeigen (SPS- 

Wert, normierter Wert der Sensoranpassung, sprachumgeschalteter Wert, Wert der 

variablenabhängigen Umrechnung cm/mm/inch/mil 

• zwei Schaltflächen für die Sprachumschaltung 

• zwei Schalter, die die Steuervariablen der variablenabhängigen Einheitenklassen 

manipulieren. 

Zur Vereinfachung ist die Reihenfolge der durchzuführenden Schritte so angeordnet, dass 

sich die Definitionen und Objekte einfach miteinander verknüpfen lassen: 

Definitionsebene Anlegen und Verknüpfen der Definitionen in der Projektdatenbank 

Design Oberflächenelemente platzieren und parametrieren 

Testlauf Ansicht des Ergebnisses


4.4.2.2 Definitionsebene 


• Legen sie zwei interne Variablen vom Datentyp VT_I2 an. Markieren Sie dazu den 

Projektexplorerknoten "Variablen→Kanäle→Intern". Öffnen sie den Tabelleneditor zu 

dem "Intern"-Kanal durch einen Doppelklick auf den Knoten. Markieren Sie den 

Tabelleneditor durch eine Mausklick und fügen sie die beiden Variablendefinitionen 

durch Drücken der Taste "F8" ein. Ändern Sie die Namen der beiden Variablen auf 

"DistanceSensorAdaptionSwitch" und "DistanceSensorExtendedSwitch". 

• Legen Sie zwei variablenabhängige Einheitenklassen an. Wechseln Sie dazu im 

Projektexplorer zum Knoten "Variablen→Einheitenklassen→variablenabhängig". 

Drücken Sie im Projektexplorer direkt die Taste "F8" zum Anlegen einer neuen 

Definition. Passen sie die Parameter der Einheitenklassen in der VisiWinNET- 

Eigenschaftenseite wie folgt an: 

Parameter Einheitenklasse 1 Einheitenklasse 2 

Name DistanceSensorAdaption LenghtConversionExtended 

Umschaltvariable DistanceSensorAdaptionSwitch DistanceSensorExtendedSwitch 

• Markieren sie den Knoten der Einheitenklasse "DistanceSensorAdaption" und fügen sie 

im Tabelleneditor zwei neue Einheitendefinitionen mit folgenden Parametern ein: 

Parameter 1. Einheit 2. Einheit 

Umschaltkennung 0 1 

X1 0 0 

X2 1 12599 

Y1 0 0 

Y2 1 16000 

• Wechseln sie im Projektexplorer zur Einheitenklasse "LenghtConversionExtended" und 

fügen sie hier im Tabelleneditor vier neue Einheitendefinitionen mit folgenden 

Parametern ein: 

Parameter 1. Einheit 2. Einheit 3. Einheit 4. Einheit 

Umschaltkennung 0 1 2 3 

X1 0 0 0 0 

X2 16000 16000 16000 16000 

Y1 0 0 0 0 

Y2 100 39,37 1000 39370 

Einheitentext cm in. mm mil. 

• Legen Sie eine sprachabhängige Einheitenklasse an. Wechseln Sie dazu im 

Projektexplorer zum Knoten "Variablen→Einheitenklassen→sprachabhängig". Drücken 

Sie im Projektexplorer direkt die Taste "F8" zum Anlegen einer neuen Definition. Ändern 

Sie den Namen der Einheitenklasse in "LengthConversion".



• Markieren sie den Knoten der Einheitenklasse "LengthConversion" und fügen sie im 

Tabelleneditor zwei neue Einheitendefinitionen mit folgenden Parametern ein: 

Parameter 1. Einheit 2. Einheit 

Umschaltkennung German (1031) English (1033) 

X1 0 0 

X2 16000 16000 

Y1 0 0 

Y2 100 39,34 

Einheitentext cm in. 

• Legen Sie die umzurechnende Variable fest. Fügen Sie dazu über den 

Projektexplorerknoten "Variablen→Kanäle" einen neuen Kommunikationskanal vom Typ 

VisiWinNET Treiber an. Legen Sie im Parameter "Treibername" den Demo Treiber fest. 

Öffnen Sie über den Kontextmenüeintrag "Variablen Browsen" des neu eingefügten 

Treiberkanal-Knoten den BrowserDialog. Wählen Sie hier die Variable 

"DataTypesSingle→Real" aus und bestätigen die Auswahl über die OK-Taste. 

• Markieren Sie den Knoten "Variablen→Extern→Ch1:Demo→DataTypesSingle" mit 

einem Doppelklick. 

• Fügen Sie zwei neue Variablendefinitionen in den Kommunikationskanal ein, indem sie 

zweimal auf dem Tabelleneditor die Taste "F8" drücken. Ändern sie die folgenden 

Parameter der drei Variablen: 

Parameter Variable 1 Variable 2 Variable 3 

Alias Distance_Real_Raw Distance_Real_Sensor- 

Independent 

Distance_Real_Sensor- 

Independent_Ext 

ItemID (schon angegeben) (wie Variable 1) (wie Variable 1) 

Datentyp schon angegeben (wie Variable 1) (wie Variable 1) 

Einheiten- 

klasse 

(Prozess) 

Einheiten- 

klasse 

(Anzeige) 

DistanceSensorAdaption DistanceSensorAdaption 

LenghtConversion LenghtConversionExtended 

Erklärungsbedarf? 

Bei allen drei Variablendefinitionen soll die ItemID identisch sein. 

Damit greift die Visualisierung über drei verschiedene 

Variablendefinitionen auf den selben Wert in der 

Kommunikationskomponente zu. 

Frage: Warum das alles? 

Antwort: Wird ein Variablenwert über eine Einheitenklasse 

(Prozess) zwischen Kommunikationskomponente und 

Variablenkern umgerechnet, steht der Rohwert aus der 

Kommunikationskomponente nirgendwo mehr zur Verfügung. Die 

einzige Chance, die Umrechnung der Einheitenklasse (Prozess) in


4.4.2.3 Design 


der Ansicht zu umgehen, ist die Definition einer zweiten Variablen, 

die keine Einheitenklasse (Prozess) verwendet, aber auf die gleiche 

Variable in der Kommunikationskomponente zugreift. Um die 

Umrechnung in der Applikation zu zeigen, wird in den folgenden 

Schritten auch der nicht umgerechnete Wert als Anzeigewert in 

der Applikation implementiert. 

• Legen Sie, wie in der Grafik gezeigt, folgende Steuerelemente auf ein Formular: 

Legen Sie die Eigenschaften der Steuerelemente, wie folgt, fest: 

Für VarIn1 

Eigenschaft Wert 

VWItem Ch1.Distance_Real_Raw 

Label.Text.Text Sensor raw value 

Für VarIn2 


VWItem Ch1.Distance_Real_SensorIndependent 

Label.Text.Text Distance (sensor independent) 

Für VarIn3 


VWItem Ch1.Distance_Real_SensorIndependent 

VWItem.Unit- 

Conversion 

True 

Label.Text.Text Distance (sensor independent) 

UseItemUnit True


Für VarIn4 



VWItem Ch1.Distance_Real_SensorIndependent_Ext 

VWItem.Unit- 

Conversion 

True 

Label.Text.Text Language dependent distance (ext.) 

UseItemUnit True 

Für Switch1 


VWItem DistanceSensorAdaptionSwitch 

LocalizedText.Text Type A 

LocalizedText.TextOn Type B 

Für Switch2 


VWItem DistanceSensorExtendedSwitch 

VWItem.BitNumber 1 

LocalizedText.Text Normal 

LocalizedText.TextOn Milli 

Für CommandButton1 


Events Verknüpfung des Click-Ereignisses mit zwei Systemfunktionen: 

LocalizedText.Text DE 

Für CommandButton2 


• ChangeLanguage mit Parameter LCID= 1031 

• ResetBit mit Parameter 

Name = "DistanceSensorExtendedSwitch" 

Events Verknüpfung des Click-Ereignisses mit zwei Systemfunktionen: 

LocalizedText.Text GB 

• ChangeLanguage mit Parameter LCID= 1033 

SetBit mit Parameter 

Name = "DistanceSensorExtendedSwitch"


Die so parametrierten Steuerelemente haben folgende Funktion: 


VarIn1 Hat ohne Umrechnungen eine Verknüpfung auf den SPS-Wert. 

Hier kann der SPS-Wert simuliert eingegeben werden. 

Switch1 Schaltet die Umschaltvariable der Einheitenklasse 

"DistanceSensorAdaption" und damit die Anpassung an den 

entsprechenden Sensortypen. 

VarIn2 Verwendet die Variablendefinition, die die Umrechnung zur 

Normierung der beiden Sensortypen beinhaltet. Die ebenfalls 

verknüpfte sprachabhängige Umrechnung wird im Steuerelement 

jedoch nicht verwendet, weil 'VWItem.UnitConversion' auf 'False' 

(Defaultwert) steht. 

Hier wird also nur der normierte Wert angezeigt 

CommandButton1 Auf ein Klick werden zwei Vorgänge ausgelöst: 

• Die Sprache wird umgestellt auf Deutsch 

• In der Umschaltvariablen für die Einheitenklasse 

"LenghtConversionExtended" wird das Bit 0 auf "0" gesetzt 

CommandButton2 Auch hier wieder zwei Funktionen: 

• Die Sprache wird umgestellt auf Englisch 

• In der Umschaltvariablen für die Einheitenklasse 

"LenghtConversionExtended" wird das Bit 0 auf "1" gesetzt 

Das Setzen der Umschaltvariablen wird im Zusammenspiel mit der 

Funktion des Switch2-Steuerelementes durchgeführt 

VarIn3 Verwendet die gleiche Variablendefinition, wie VarIn2 und damit 

die Einheitenklasse (Prozess). Zusätzlich ist hier die 

Einheitenklasse (Anzeige) über 'VWItem.UnitConversion' aktiviert 

.Über die Eigenschaft ''UseItemUnit' wird zusätzlich der 

sprachabhängige Einheitentext angezeigt 

Switch2 Manipuliert Bit 1 in der Umschaltvariablen für die Einheitenklasse 

"LenghtConversionExtended". Zusammen mit den beiden 

'CommandButton'-Steuerelementen ergeben sich für die 

Steuervariable folgende Kombinationen: 

Sprache Funktion 

Switch2 

Wert der Umschalt- 

variablen (bitkombiniert) 

DE Normal 0 (00) cm 

GB Normal 1 (01) in. 

DE Milli 2 (10) mm 

GB Milli 3 (11) mil. 

Angezeigte Einheit



VarIn4 Verwendet die Variablendefinition 

"Ch1.Distance_Real_SensorIndependent_Ext" und damit die 

Einheitenklasse "LenghtConversionExtended". Hier wird der Wert 

angegeben, der sowohl über die Sprache als auch über das 

"Switch2"-Steuerelement umzuschalten ist. 

4.4.2.4 Testlauf 

Starten Sie das Projekt und führen Sie folgende Schritte aus: 

Anweisung Beobachtung 

Geben Sie im VarIn1 

den Wert 16000 ein 

Ändern Sie den Wert 

auf 12599 (max. Wert 

für den Sensortyp B) 

und drücken Sie auf 

Switch1 

Schalten Sie die 

Sprache auf Englisch 

In VarIn2 wird der Wert übernommen (Die entsprechend aktive 

Einheitendefinition beschreibt eine Gerade ohne Offset mit der 

Steigung 1 

In VarIn3/4 wird der entsprechende Wert "100 cm" angegeben 

In VarIn2 wird wieder 16000 angezeigt. diesmal über die 

Umrechnung der Einheitenklasse "DistanceSensorAdaption" 

errechnet 

In VarIn3/4 wird der entsprechende Wert "100 cm" angegeben 

Die Anzeige in VarIn3/4 springt jeweils zur Einheit Inch 

Drücken Sie Switch2 In VarIn4 wechselt die Anzeige zum Wert für die Einheit "mil."


4.4.3 FAQ zu Einheitenklassen 

Ich möchte eine 

Einheitenumschaltung in einer 

Struktur verwenden. Wie geht das? 

Nach einer Eingabe in ein 'VarIn'- 

Steuerelement, dass eine 

Einheitenumschaltung verwendet, 

springt der Wert um. Eine Variable 

vom Datentyp VT_I4 wird dabei 

verwendet 

Die Einheitenumschaltung im 

'VarIn'-Steuerelement wird nicht 

ausgeführt 

Definitionen der Prozessanbindung / Einheitenklasse / FAQ zu Einheitenklassen 52 

Die beiden Parameter "Einheitenklasse (Anzeige)" 

und "Einheitenklasse (Prozess)" in der 

Prozessvariablendefinition haben keine Funktion 

mehr, wenn die Variable vom Datentyp einer 

Struktur ist. 

Jedes Strukturelement beinhaltet aber Pendants 

zu den beiden Parameter. 

Übrigens: ist eine Prozessvariable als Datenfeld 

definiert (Feldgröße> 0) werden auf alle 

Feldelemente die in der 

Prozessvariablendefinition angegebenen 

Einheitenklassen angewendet. 

Höchstwahrscheinlich ein Quantisierungsfehler. 

Der Variablenkern rechnet automatisch bei 

einheitenbehafteten Variablen intern im 

Fliesskommazahlenbereich. Spätestens aber, 

wenn der Wert auf die SPS zurückgeschrieben 

wird, kann es zu einem auf- oder abrunden 

kommen. Der gerundete Wert wird nach dem 

Schreiben zurückgemeldet an das Steuerelement. 

dass dann in der Anzeige umspringt. 

Abhilfe: Fließkommazahlen in der SPS verwenden 

und Bruchrechnungen in der Einheitenklasse 

vermeiden. 

Überprüfen Sie folgende Einstellungen: 

• Sind in der erwarteten Einheitenklasse 

wirklich unterschiedliche 

Einheitenumrechnungen mit sinnvollen 

Werten für X1, X2, XY und Y2 vorhanden? 

• Ist die im 'VarIn' angebundene 

Prozessvariable mit der Einheitenklasse 

verknüpft? 

• Ist im 'VarIn' die Eigenschaft 

'VWItem.UnitConversion' auf 'true' 

eingestellt? 

• Ist die Bedingung für die erwartete 

Einheitenumrechnung, also der Schalter, der 

die Einheit in der Einheitenklasse auswählt 

(Sprache oder Wert der Steuervariablen), 

erfüllt?


4.5 Einheit 

Definitionen der Prozessanbindung / Einheit / FAQ zu Einheitenklassen 53 

Einheitenobjekte repräsentieren die Umschaltmöglichkeiten einer Einheitenklasse. Die 

wesentlichen Informationen dabei sind die Formel zur Umrechnung und die Angabe des 

Zustandes (Sprache oder Prozessvariablenwert), der eingenommen werden muss, damit die 

Formel aktiv wird. 

Einheitenobjekte beinhalten u.a. folgende Funktionalität: 

• Eingabe der Umrechnung über eine Zweipunktedefinition (Geradengleichung über x1, 

y1, x2, y2). 

• Zusätzliche Angabe eines Einheitentextes 

• Verschiebung von Dezimalstellen, so dass ganzzahlige Werte als Fließkommawerte in 

der Visualisierung erscheinen 

Parameter des Einheitenobjektes 


Einheitentext Zusätzlich zu übergebender Text, der in der Visualisierung 

angezeigt werden soll. 

Kommaverschiebung Verschiebung von ganzzahligen Werten um Dezimalstellen 

Umschaltkennung Beschreibt den Zustand, damit diese Einheit in der Einheitenklasse 

als Umrechnung benutzt wird. 

x1 Beschreibt den 1. Rohwert der Geradengleichung 

x2 Beschreibt den 2. Rohwert der Geradengleichung 

y1 Beschreibt den 1. Umrechnungswert der Geradengleichung 

y2 Beschreibt den 2. Umrechnungswert der Geradengleichung


Definitionen der Prozessanbindung / Einheit / Einheiten bearbeiten 54 

4.5.1 Einheiten bearbeiten 

Einheiten werden in Einheitenklassen projektiert und im Tabelleneditor angezeigt. Jede 

Einheitendefinition beinhaltet einen editierbaren Parametersatz: Hier wird festgelegt, wann 

eine Einheit in der Einheitenklasse aktiv ist. Auch werden hier die Informationen zur 

Einheitenumrechnung hinterlegt. 



Der Editor bietet folgende Funktionen zum Projektieren von Einheiten: 

Neu erzeugen Über Eintrag "Neu" im Kontextmenü des Tabelleneditors wird eine 

neue Einheitendefinition in das Projekt eingefügt 

Parameter 

bearbeiten 

Die VisiWinNET-Eigenschaftenseite zeigt die Parameter der im 

Tabelleneditor markierten Einheitendefinition an. Das Bearbeiten 

der Parameter ist aber auch direkt in den Feldern des 


Löschen Eine oder mehrere Einheitendefinitionen können gelöscht werden, 

indem: 





"Löschen" gewählt wird.


4.6 Struktur 

Strukturdefinitionen repräsentieren erweiterte Datentypen für 

Prozessvariablendefinitionen. 

Prozessvariablen bieten verschiedene Zugriffsarten auf Daten einer SPS: 

Definitionen der Prozessanbindung / Struktur / Einheiten bearbeiten 55 

• Einzelzugriff (einfache Datentypen): Die Anforderung eines Prozessvariablenwertes löst 

dabei zwischen Kommunikationskomponente und SPS einen Protokollaufruf aus. 

Allgemein gilt, dass die Übertragung von Daten zwischen der SPS und dem PC in 

umfangreichen Applikationen ein zeitkritisches Nadelöhr sein kann. Jeder Lese- 

/Schreibzugriff auf den SPS-Speicher benötigt ein Rahmenprotokoll. 

• Blockweiser Zugriff (Felder einfacher Datentypen): Dabei wird ein Speicherbereich 

übertragen, der Speicherzellen vom Datentyp der Prozessvariablen enthält. Dies hat den 

Vorteil, dass für die Übertragung des gesamten Speicherbereiches nur ein 

Rahmenprotokoll benötigt wird. 

• Erweiterter blockweiser Zugriff (Strukturen): Auch hier wird ein Speicherbereich 

übertragen. Der Variablenkern löst diesen Speicherbereich jedoch in einzelne 

Prozessvariablen auf, die der zugeordneten Strukturdefinition entsprechen. Während 

ein Feld also nur Daten des gleichen Datentyps (z.B. VT_I4) enthalten kann, darf eine 

Struktur Speicherzellen verschiedener Datentypen enthalten (VT_I2, VT_I4, VT_R4,...). 

Parameter der Strukturdefinition 



Name Bezeichner der Definition 

Ordnungsnummer Die Ordnungsnummer der Strukturelemente wird entweder als 

als Byteoffset Byteoffset oder als Reihenfolgenummer interpretiert


Definitionen der Prozessanbindung / Struktur / Strukturen bearbeiten 56 

4.6.1 Strukturen bearbeiten 

Strukturen werden im Projektexplorer unter dem gleichnamigen Knoten dargestellt. Jede 

Strukturdefinition beinhaltet: 

• einen editierbaren Parametersatz: Hier kann der Name und die Interpretation der 

Ordnungsnummer der Strukturelemente eingestellt werden. 

• ggf. Strukturelemente: Im Tabelleneditor werden nach dem Markieren einer Struktur die 

zugehörigen Elemente dargestellt. 

Strukturen werden zur Beschreibung von komplexen Datentypen in Prozessvariablen 

verwendet. Die Namen der projektierten Strukturen finden sich in der Auswahlliste des 

Parameters "Datentyp" von Prozessvariablen wieder. 

Der Editor bietet folgende Funktionen zum Projektieren von Strukturen: 

Neu erzeugen Über Eintrag "Neu" im Kontextmenü des Knotens "Strukturen". 

Parameter 

bearbeiten 

Ein Klick auf eine Struktur lädt die entsprechenden Parameter in 

die VisiWinNET-Eigenschaftenseite. Hier können die 


Löschen Über den Eintrag "Löschen" im Kontextmenü eines Strukturknotens 

wird die Definition gelöscht. Dabei werden auch die enthaltenen 

Elemente gelöscht. 

4.6.2 Verwendung von Strukturen 

Strukturen in VisiWinNET beschreiben einen zusammenhängenden Speicherbereich in der 

SPS, in dem einzelne Prozessvariablen gleicher oder unterschiedlicher Datentypen 

aufeinander folgen. 

Typischerweise bilden diese Datenblöcke in der SPS einzelne Visualisierungsfunktionen ab, 

wie z.B: 

• Regler: Die einzelnen Reglerparameter werden in einem physikalisch 

zusammenhängenden Speicherbereich abgebildet 

• Rezepte: Alle Werte, die z.B. eine Chargenproduktion parametrieren, werden 

nacheinander im SPS-Speicher angeordnet 

• Anlagenkomponenten: Besteht die zu visualisierende Maschine aus mehreren (ggf. auch 

baugleichen) Komponenten, deren Funktion jeweils auf einer einzelnen Applikationsseite 

(Formular) dargestellt wird, sollten entsprechende Speicherblöcke vom SPS- 

Programmierer vorgesehen werden.


Definitionen der Prozessanbindung / Struktur / Verwendung von Strukturen 57 

Strukturen optimieren die Kommunikation dahingehend, dass mehrere Prozessvariablen im 

Rahmen eines Speicherblocks mit nur einem Protokollrahmen gelesen werden, d.h.: 

• Ist auf ein oder mehrere Elemente einer Struktur eine Leseanforderung aktiv, werden 

alle Elemente der Struktur durch einen blockweisen Zugriff aus der SPS gelesen. 

• Das Schreiben auf ein Strukturelement wird in einem Protokollrahmen nur auf die 

entsprechende Speicherzelle in der SPS ausgeführt. 

DB10.0 

DB10.1 

DB10.2 

DB10.3 

DB10.4 

DB10.5 

DB10.6 

DB10.7 

DB10.8 

DB10.9 

DB10.10 

DB10.11 

DB10.12 

DB10.13 

DB10.14 

SPS 

Flags (VT_UI1) 

Value (VT_I2) 

Diff (VT_R4) 

Int (VT_R4) 

Prop (VT_R4) 

READ 

Startadresse = ItemID 

Länge = Länge der Struktur 

*) Für OPC-Server: Der schreibende Zugriff auf einzelne 

Strukturelemente ist nur möglich, wenn im Kommunikationskanal 

die Option "Einzelzugriff auf Feldelemente" aktiv ist 


Protokollrahmen "Lesen" 

DB10.0 DB10.1 ... DB10.14 

Protokollrahmen "Schreiben" 

DB10.11 ... DB10.14 

Zuordnung zu 

Strukturelementen 

Struktur im Variablenkern 

WRITE *) 

Startadresse = ItemID+Offset des Elementes 

Länge = Länge des Datentyps 

Flags (VT_UI1) 

Value (VT_I2) 

Diff (VT_R4) 

Int (VT_R4) 

Prop (VT_R4) 

Im obigen Beispiel bilden die Prozessvariablen "Flags", "Value", "Diff", "Int" und "Prop" einen 

zusammenhängenden Speicherbereich in der SPS. In der Visualisierung wird beim Lesen der 

gesamte Datenblock über einen Protokollrahmen geholt. Im Variablenkern werden die 

gelesenen Bytes den entsprechenden Variablen im Prozessabbild zugeordnet. Von hier aus 

werden die Werte (z.B.. über Steuerelementeanbindungen) auf der Visualisierungsoberfläche 

abgebildet. Wird ein Wert im Rahmen der Visualisierungsapplikation geändert, berechnet 

der Variablenkern die Adresse für den Schreibauftrag über den Offset der Variablen 

innerhalb der Struktur und der Startadresse, also der ItemID der Variablendefinition. 

Es obliegt immer dem SPS-Programmierer, die Prozessvariablen 

sinnvoll in Datenblöcken anzuordnen. Er hat damit entscheidenden 

Einfluss auf die Performance der Kommunikation zwischen SPS 

und Visualisierung, da Strukturen als Datenblöcke ausgetauscht 

werden. 

Dem SPS-Programmierer stehen zur blockweisen Anordnung der 

Prozessvariablen verschiedene Mittel zur Verfügung: 

• Definition von Strukturen in der SPS (z.B. CoDeSys, Allen 

Bradley): Der Zugriff ist hier üblicherweise auf die gesamte 

Struktur oder auf die einzelnen Elemente möglich. 

• Deklarationsreihenfolge innerhalb eines Datenbausteines (z.B. 

STEP 7): Nacheinander deklarierte Variablen belegen hier 

einen zusammenhängenden Speicherbereich 

• Deklaration von Variablenfeldern: Sicherlich die 

unkomfortabelste Lösung, weil dem SPS-Programmierer nur



noch der indizierte Zugriff auf die Feldelemente zur Verfügung 

steht und er damit die Auflösung in die verschiedenen 

beinhalteten Datentypen selbst managen muss. 

In der Praxis muss in Visualisierungsapplikationen mit vielen 

Variablen fast immer optimiert werden. Dabei ist auch die 

gewählte Kommunikationskomponente ein Kriterium für die 

Verwendung von Strukturen: 

• VisiWin-Treiber: Verwendung von Strukturen nahezu 

zwingend erforderlich. Die kennen keine Blockung/keine 

Protokolloptimierung. Variablen, die nacheinander in einem 

physikalisch zusammenhängenden Speicherbereich angeordnet 

sind, können als Block (Byte-/Wort-Array) übertragen werden. 

In der Visualisierung werden über die Strukturdefinition die 

einzelnen Bytes wieder den entsprechenden Datentypen 

zugeordnet. 

• OPC-Server: Ein als Bytearray übertragener Speicherbereich 

wird in der Visualisierung über eine Strukturdefinition in 

Variablen aufgeteilt. Nicht immer zwingend notwendig, wenn 

z.B. der OPC-Server intern eine Blockung (Zusammenfassung 

der einzelnen Lese-/Schreibauftäge zu Datenblöcken) 

unterstützt. Auch muss der OPC-Server die Übertragung als 

Bytearray unterstützen. 

• VWN-Treiber: Bei Treibern, die keine Blockung unterstützen, 

kann der Datenaustausch wie bei den klassischen VisiWin- 

Treibern optimiert werden. Ob der Treiber eine Blockung 

unterstützt, wird in der treiberspezifischen Hilfedatei 

aufgeführt. 

In der Entwicklungsumgebung sind Strukturen als Datentypvorgaben auf Variablen 

anzuwenden, d.h. die im Projekt definierten Strukturen erweitern die Liste der einfachen 

Datentypen von Prozessvariablen. 

Die Projektierung gliedert sich in zwei Schritte: 

Definition der 

Struktur 

Unter dem Zweig "Strukturen" im VisiWinNET Projektexplorer wird 

eine Struktur definiert. Eine Struktur beinhaltet im wesentlichen 

einen Namen und natürlich Elemente, die die elementaren 

Datentypen verwenden und damit den Aufbau des Datenblockes 

bestimmen. Wird die Länge der einzelnen Elemente (in Bytes) 

aufsummiert, muss das Ergebnis der Datenblocklänge in der SPS 

entsprechen.


Anlegen einer 

Variablen 


Innerhalb des entsprechenden Kommunikationskanals ist eine 

Variable anzulegen. Die ItemID der Prozessvariablen legt die 

Startdresse des Datenblocks in der SPS fest. Über die Auswahl der 

Struktur im Feld "Datentyp" wird die Lage der einzelnen Variablen 

im Datenblock bestimmt. 

Manche Kommunikationskomponenten (hier z.B. OPC Server S7 

TCPIP von der INOSOFT) erwarten zusätzlich die Länge des 

Datenblocks als Angabe in der ItemID (hier "[15]").



Die einzelnen Elemente im Datenblock können z.B. bei der Anbindung an Steuerelemente 

wie gewohnt im Variablenauswahldialog angesprochen werden. Syntaktisch werden hier bei 

der Auswahl die Elemente in spitze Klammern eingefasst. 

Weitere Hinweise: 

• Strukturen dürfen geschachtelt werden, d.h. ein 

Strukturelement darf auch vom Datentyp einer Struktur sein. 

Die maximale Verschachtelungstiefe beträgt 10. 

• Bei der Definition der Strukturen und der Datenblöcke ist das 

sogenannte "Alignment" (die Verschiebung von Speicherzellen 

auf gerade Adressen, häufig entsteht z.B. ein Loch im linearen 

Speicherbereich, wenn ein Wort (VT_I2) eigentlich auf eine 

ungerade Adresse geschoben werden soll, weil es auf ein Byte 

auf einer geraden Adresse folgt) in der SPS zu beachten. 

Strukturdefinitionen in VisiWinNET dürfen Löcher (quasi nicht 

belegte Bytes) enthalten. Über den Parameter 

"Ordnungsnummer als Byteoffset" in der Strukturdefinition 

kann der Offset eines Elementes direkt als Byteoffset 

angegeben werden.


FAQ 


• Frage: Was ist der Unterschied zwischen einem Feld und einer 

Struktur? 

Antwort: Während Variablenfelder nur Elemente des gleichen 

Datentyps enthalten können, ist eine Struktur ein Mix aus 

Elementen unterschiedlicher Datentypen 

• Frage: Warum sind die beiden Worte in meinem als VT_I4 

definierten Strukturelement offensichtlich vertauscht? 

Antwort: Das typische Datenorganisations-Problem. Manche 

SPSen organisieren die beiden 16-Bit-Worte eines Langwortes 

aus der Perspektive des Betriebssystems falsch herum. Eine 

entsprechende Einstellung zur Korrektur dieses Fehlers 

befindet sich A) entweder in der Konfiguration der 

Kommunikationskomponente oder B) in der Definition des 

Kommunikationskanals. 

• Frage: Was ist der Perfomancegewinn bei der Verwendung von 

Strukturen gegenüber dem Zugriff auf einzelne Variablen? 

Antwort: Wir können keine Aussage treffen. Aber hier ein 

Extrembeispiel: Lesen von 1000 Worten. Wenn ein Lesebefehl 

z.B. aus 1 Byte Anweisung, 2 Byte Adresse, 2 Byte Länge 

besteht, zu jedem Leseaufruf die entsprechende Rückantwort 

aus 5 Byte erfolgt, werden bei der Anfrage auf 1000 Wörter 

10kB Daten übertragen. Davon sind 2kB Nutzdaten (Verhältnis 

5/1). Das Verhältnis Protokolldaten/Nutzdaten wird durch die 

Blockweise Übertragung nahezu auf 1 reduziert. Als 

zusammenhängender Block über einen gemeinsamen 

Lesebefehl könne die 2kB Nutzdaten mit nur einem 

Protokollzugriff übertragen werden. Bei einer langsamen 

Verbindung (z.B. serielle Kommunikation mit 9600 Baud) kann 

der Performancegewinn entscheidend sein.


4.7 Strukturelement 

Definitionen der Prozessanbindung / Strukturelement / Verwendung von Strukturen 62 

• Frage: Beim Browsen über den S7 OPC-Server bekomme ich 

alle Variablen einzeln in mein Projekt. Genieße ich jetzt noch 

den Vorteil des blockweisen Zugriffs? 

Antwort: Nicht, wenn der OPC-Server intern keine Blockung 

unterstützt. Dann muss manuell eine Strukturdefinition im 

Projekt angelegt werden, die den Aufbau des entsprechenden 

Datenbausteines wiedergibt. Über die Definition einer 

Variablen vom Typ der Struktur und der Adresse, die den 

Datenblock beschreibt (Datenbaustein, Startadresse und 

Länge, siehe Dokumentation des OPC-Servers) muss der 

blockweise Zugriff erst wieder ermöglicht werden. 

• Frage: Etwas passt beim Aufbau meiner Struktur nicht. Werte, 

die sich offensichtlich in der SPS ändern, werden nicht in der 

Visualisierung angezeigt oder Änderungen wirken sich auf ein 

falsches Strukturelement aus. 

Antwort: Ist in der Strukturdefinition der Parameter 

"Ordnungsnummer als Byteoffset" aktiv, wird eine 

Doppelbelegung des Parameters "Ordnungsnummer" in den 

Strukturelementen nicht mehr überprüft. Kontrollieren Sie 

diesen Parameter genau (auch in Hinblick auf das Alignment). 

Strukturelemente definieren die Speicherzellen einer Strukturdefinition. Als wichtigste 

Informationen werden dabei der Datentyp und der Offset innerhalb der Struktur 

angegeben. 

Strukturelemente beinhalten u.a. folgende Funktionalität: 

• Unterstrukturierung mit Hilfe des Datentyps 

• Zugriff auf Datenfelder 

• Sprach-/Variablenwert-abhängige Umrechnung von Prozessvariablenwerten 

(Einheitenklassen) 

Parameter des Strukturelementobjektes 


Datentyp Bestimmt den Aufbau und die Länge des Strukturelementwertes 


(Anzeige) 

Verweis auf eine sprach- oder variablenabhängige Umrechnung 


(Prozess) 

Verweis auf eine Variablenwert-abhängige Umrechnung 

Ersatzwert Wert, der anstelle des wahren Prozesswertes weitergereicht wird 

Feldgröße Anzahl der Prozessvariablen bei blockweisem Zugriff 

Variablenoptionen Bitcodierte Einstellungen zur Prozessvariablen 

Kommentar Wahlfreier Kommentar zur Definition


Definitionen der Prozessanbindung / Strukturelement / Strukturelemente bearbeiten 63 

Maximalwert Oberer Grenzwert, den das Strukturelement annehmen darf 

Minimalwert Unterer Grenzwert, den das Strukturelement annehmen darf 


Ordnungsnummer Byteoffset oder Reihenfolgennummer des Elementes im 

Strukturspeicherbereich 

Text Sprachumschaltbarer Text zur Variablen 

4.7.1 Strukturelemente bearbeiten 

Strukturelemente werden in Strukturen projektiert und im Tabelleneditor angezeigt. Jedes 

Element beinhaltet einen editierbaren Parametersatz: Hier wird unter anderem festgelegt, 

welchen Datentyp das Element beschreibt und wo sich das Element in der Struktur befindet. 



Der Editor bietet folgende Funktionen zum Projektieren von Strukturelementen: 

Neu erzeugen Über Eintrag "Neu" im Kontextmenü des Tabelleneditors wird ein 

neues Strukturelement in das Projekt eingefügt 

Parameter 

bearbeiten 

Die VisiWinNET-Eigenschaftenseite zeigt die Parameter des im 

Tabelleneditor markierten Strukturelementes an. Das Bearbeiten 

der Parameter ist aber auch direkt in den Feldern des 


Löschen Eine oder mehrere Elemente können gelöscht werden, indem: 





"Löschen" gewählt wird.


4.8 Multiplexer 

Visualisierung 

(Steuerelemente, ...) 

Ausgabevariablen 

ItemOut1 

ItemOut2 

ItemOut3 

Definitionen der Prozessanbindung / Multiplexer / Strukturelemente bearbeiten 64 

Multiplexer 

Umschaltvariable 

Eingangsvariablen 

ItemIn11 

ItemIn12 

ItemIn13 

ItemIn11 

ItemIn12 

ItemIn13 

ItemIn11 

ItemIn12 

ItemIn13 

Technisch gesehen ist ein Multiplexer ein Mehrfachumschalter. In der Praxis wird über 

Multiplexer eine Umschaltung von Variablengruppen erreicht. Liegen beispielsweise Daten 

mehrerer Regler in der SPS, kann in der Applikation über einen Multiplexer ein Formular 

projektiert werden, dass jeweils die Daten eines Reglers anzeigt, dabei aber über einen 

Umschalter zwischen den Reglern wechseln kann. 

Die Umschaltung wird mithilfe der Umschaltvariable realisiert. Zu definieren ist zusätzlich: 

• welche Ausgabevariablen sollen die Daten enthalten, die in der Applikation angezeigt 

werden? 

• welche Werte muss die Umschaltvariable einnehmen, damit zu einem Satz 

Eingangsvariablen gewechselt wird? 

• welche Eingangsvariablen liefern die Daten für welchen Zustand der 

Umschaltvariablen? 

Der Variableneditor repräsentiert diese Daten in Form einer Tabelle mit einer vom 

Projekteur zu definierenden Anzahl von Spalten und Zeilen. Durch das Hinzufügen einer 

Zeile wird eine neue Ausgabevariable definiert. In der ersten Tabellenspalte steht der Name 

der Ausgabevariablen. 

Jede weitere Spalte beschreibt über den Wert der Umschaltvariablen im Spaltenkopf einen 

Umschaltzustand. In den Feldern dieser Spalten werden die Eingangsvariablen erwartet, die 

für diesen Zustand mit der Ausgabevariablen der entsprechenden Zeile verbunden sein 

sollen. 

Parameter der Multiplexerdefinition 


Kommentar Wahlfreier Kommentar zur Definition 


Umschaltvariable Legt die Variable fest, deren Wert als Schalter zwischen den 

Umschaltzuständen verwendet wird 

Umschaltzustände Legt fest, zu welchen Variablen gewechselt wird, wenn die 

Umschaltvariable den Wert ändert.


Definitionen der Prozessanbindung / Multiplexer / Multiplexer bearbeiten 65 

4.8.1 Multiplexer bearbeiten 

Multiplexer werden im Projektexplorer unter dem gleichnamigen Knoten dargestellt. Jede 

Multiplexdefinition beinhaltet: 

• einen editierbaren Parametersatz: Hier wird der Name und die Umschaltvariable 

festgelegt. Außerdem wird über die Definition von Umschaltzuständen bestimmt, welche 

Werte die Umschaltvariable einnehmen kann. 

• die Variablenzuordnung: Über eine Zuordnungstabelle werden Variablensätze 

projektiert. Jeder Variablensatz beinhaltet einen Alias und ein Feld für jeden 

Umschaltzustand. Über den Alias wird der Variablensatz an Steuerelemente 

angebunden. In den Feldern der Umschaltzustände wird eingetragen, welche Variable 

zum Alias umgelenkt wird. 

Der Editor bietet folgende Funktionen zum Projektieren von Multiplexern: 

Neu erzeugen Über Eintrag "Neu" im Kontextmenü des Knotens "Multiplexer". 

Parameter 

bearbeiten 

Ein Klick auf einen Multiplexer lädt die entsprechenden Parameter 

in die VisiWinNET-Eigenschaftenseite. Hier können die 



Multiplexerknotens wird die Definition gelöscht. Dabei werden 

auch die enthaltenen Variablensätze gelöscht. 

Die Variablensätze im Tabelleneditor werden über den Parameter "Umschaltzustände" 

des Multiplexers parametriert. Jeder neu hinzugefügte Umschaltzustand erweitert die 

Variablensatzztabelle um eine entsprechende Spalte. Hier werden die Variablen 

eingetragen, die zur Laufzeit über den projektierten Alias angesprochen werden. 

Variablensätze werden über die Funktionen im Kontextmenü des Tabelleneditors als 

Tabellenzeilen neu eingefügt oder gelöscht.


Definitionen der Prozessanbindung / Multiplexer / Beispiel Multiplexer 66 

4.8.2 Beispiel Multiplexer 

Eine typische Anwendung eines Multiplexers kann anhand des Demo-OPC-Servers 

gezeigt werden. Hier sind drei gleichartige Datenstrukturen (DistillationDevice.Unit1..3) 

enthalten, die über einen Multiplexer umschaltbar darzustellen sind. 

Über die Verwendung eines Multiplexers wird der Aufbau der Applikationsoberfläche 

vereinfacht. Es müssen nur noch für eine Datenstruktur Steuerelemente projektiert 

werden. Das wiederholte Platzieren und Parametrieren von Steuerelementen, die sich 

nur in der Variablenanbindung (VWItem-Eigenschaft) unterscheiden, entfällt. 

Der Demo-OPC-Server ist als Kanal in ein Projekt einzufügen. 

Anschließend sind die Variablen des Namensraumes 

"DistillationDevice" über den "Browse"-Dialog in das Projekt zu 

übernehmen. 

Anschließend ist im Variableneditor eine interne Variable mit 

dem Namen "SwitchDistillationDeviceUnit" (Datentyp 

"VT_I2)anzulegen. 

Unter dem Knoten "Multiplexer" im Projektexplorer ist eine 

neue Multiplexdefinition anzulegen. Auf der Karteikarte 

"Standard" in der VisiWinNET-Eigenschaftenseite sind folgende 

Parameter anzupassen: 

Name Wert 

Name MuxUnits 

Umschalt- 

variable 

SwitchDistillationDeviceUnit 

Auf der Karteikarte "Erweitert" sind drei neue 

Umschaltzustände mit den Werten 1, 2 und 4 anzulegen.



Über die "Hinzufügen"-Schaltfläche werden neue Zeilen in der 

Liste erzeugt, anschließend können die Werte direkt in den 

Listenfeldern bearbeitet werden. 

Im Tabelleneditor der neuen Definition sind über den 

Kontextmenüeintrag "Neu" zwei neue Variablensätze anzulegen 

Im "Alias"-Feld sind die Werte "Kondensation" und "WaterTank" 

einzutragen. 

In den Feldern der Umschaltzustände ist über den 

Variablenauswahldialog die Zuordnung zu den entsprechenden 

Variablen aus dem OPC-Server festzulegen: 

Tabellenspalte "1" 

Alias Wert 

Kondensation DistillationDevice.Unit1.Kondensation 

WaterTank DistillationDevice.Unit1.WaterTank 


Alias Wert 




Alias Wert 



Die Variablen "Kondensation" und "WaterTank" sind über zwei 

'VarOut'-Steuerelemente in der Applikation anzubinden. 

Drei 'Switch'-Steuerelemente sind mit den Bits 0,1 und 2 der 

internen Umschaltvariable "SwitchDistillationDeviceUnit" zu 

verbinden. Die 'OptionGroup'-Eigenschaft der drei 

Steuerelemente ist jeweils auf den Wert 0 zu setzen.



Die drei Switch-Steuerelemente werden über die 'OptionGroup'- 

Eigenschaft so konfiguriert, dass immer nur ein Bit in der 

Variablen "SwitchDistillationDeviceUnit" aktiv ist. Damit nimmt 

die Variable bei Bedienung über die 'Switch'-Steuerelemente 

den Wert 1,2 oder 4 ein. Dies sind die Werte, die im Multiplexer 

als Umschaltzustände projektiert wurden. Im folgenden wird 

diese Variable zur Umschaltung des Multiplexers verwendet. 

Das Projekt ist zu starten. Der Multiplexer ist über die drei 

'Switch'-Steuerelemente zu den jeweils festgelegten Variablen 

umzuschalten. 

Eine so projektierte Anwendung erlaubt die Umschaltung 

zwischen gleichartigen Variablenblöcken. Das wiederholte 

Platzieren und Parametrieren von Steuerelementen, die sich nur 

in der Variablenanbindung unterscheiden, entfällt.


4.9 Variablenadapter 

Definitionen der Prozessanbindung / Variablenadapter / Beispiel Multiplexer 69 

Der Zugriff auf Variablenwerte aus VisiWinNET-Applikationen erfolgt über den 

vollständigen Bezeichner von Prozessvariablen. Dieser Bezeichner beinhaltet den 

Kanalnamen, den Alias der Prozessvariablen, sowie ggf. die Auflösung von Feld- und/oder 

Strukturelementen. 

Variablenadapter entkoppeln diese Anbindung durch die Einführung eines weiteren Alias. 

Zusätzlich beinhalten Variablenadapter eine konfigurierbare Umschaltung. Jedem Alias 

können zur Entwicklungszeit mehrere in den Kommunikationskanälen definierte 

Prozessvariablendefinitionen zugeordnet werden. Über einen Konfigurationseintrag wird zur 

Initialisierungsphase des Projektes festgelegt, welche Variablen tatsächlich über den Alias 

angesprochen wird. 

Problemstellung 

Variablenadapter werden als Lösung von folgenden Problemen verwendet: 

• Zur Zeit der Erstellung des Projektes ist nicht klar, welche Anbindungskonstellation 

gewählt werden muss (Anschluss aller Steuerungen über einen Kommunikationskanal / 

über mehrere Kommunikationskanäle): In der Praxis kann es sein, dass sich die 

Anbindung über nur einen Treiber als wenig performant erweist. Alle Anbindungen in 

der Applikation ("VWItem-Eigenschaft) beinhalten aber den Kanalbezeichner. Eine 

spätere Umstellung von einem auf mehrere Kommunikationskanäle erweist sich als 

äußerst arbeitsintensiv, da beispielsweise die Variablenanbindungen in den 

Steuerelementen auch angepasst werden müssen. 

• Es ist abzusehen, dass die Visualisierung unterschiedliche Steuerungen verwenden 

muss. Die Variablenbenennung ist aber auf keine Weise kompatibel zu halten: Ein 

typischer Fall hierfür ist die Anbindung über einen OPC-Server für die eine Steuerung 

und die Verwendung eines VisiWin-Treibers für die alternative Steuerung. Aufgrund 

des optimierten Austausch über Strukturen sind bei VisiWin-Treibern die 

Variablennamen in der Applikation nicht mehr kompatibel, da das Strukturelement 

durch spitze Klammern eingefasst mit in den Bezeichner der angebundenen Variable 

einfließt. 

Beide Probleme konnten bislang dazu führen, dass dieselbe Visualisierung für 

unterschiedliche Steuerungen auch mithilfe von mehreren Projekten parallel gepflegt 

werden musste.


Projektierung 

Definitionen der Prozessanbindung / Variablenadapter / Beispiel Multiplexer 70 

Um einen Variablenadapter in Betrieb zu nehmen, sind in der Entwicklungsumgebung 

folgende Schritte durchzuführen: 

• Definition aller Variablen, die in den unterschiedlichen Varianten vorkommen können, 

in mehreren Kommunikationskanälen. Variablen aus unterschiedlichen Varianten 

dürfen dabei nicht in einem Kanal definiert werden. 

• Erzeugen eines Variablenadapters im Projektexplorer 

• Festlegung der Variablen der ersten Umschaltvariante durch Hinzufügen von 

Variablensätzen im Tabelleneditor des Adapters. Jeder Variablensatz setzt sich in dieser 

Phase durch einen Standardwert und einen Alias zusammen. Ist die Applikation bereits 

mit Variablen verbunden, sollten diese als Standardwert ausgewählt werden. Eine 

weitere Applikationsanpassung erübrigt sich dadurch, da der Alias vom Editor aus dem 

Namen der Standardvariablen bildet. 

• Definition eines neuen Umschaltzustandes: In der Entwicklungsumgebung wird über 

das Hinzufügen eines Umschaltzustandes eine Spalte zur Tabelle hinzugefügt. Die 

Felder dieser Spalte sind leer. Hier müssen jetzt die Variablen eingefügt werden, die 

den Bezeichner in der Standard-Spalte ersetzen, wenn zu einer anderen Steuerung 

umgeschaltet wird. 

• Aktivierung des passenden Umschaltzustandes: Um Irrtümern vorzubeugen, eines 

gleich vorweg. Die Umschaltung kann zwar vor dem Applikationsstart konfiguriert 

werden, ist aber nicht mehr zur Laufzeit änderbar, also kein dynamisches Feature. Ggf. 

sind dem Techniker, der die Visualisierung vor Ort einrichtet, die Schritte zur 

Konfiguration der angeschlossenen Steuerungen detailliert zu beschreiben. 

Steuerelement Itemadapter-Definition 

VWItem-Eigenschaft 

Verknüpfungen über Itemadapter 

Alias Standard 

. 

. 

. 

Umschaltzust. 2 

Item-Definition (Kanal) 

Alias ItemID 

Alias ItemID 

. 

. 

. 

Items (OPC-Server) 

ItemID Name 

ItemID Name 

. 

. 

.


Parameter der Variablenadapter 


Definitionen der Prozessanbindung / Variablenadapter / Variablenadapter bearbeiten 71 

Definition aktiv Bestimmt, ob die Definition zur Laufzeit gültig ist. 



Umschaltzustände Legt fest, zu welchen Variablen gewechselt wird, wenn die 

Konfiguration des Variablenadapters den Wert ändert. 

zu deaktivierende 

Kanäle 

Legt für jeden Eintrag in der "Umschaltzustände"-Liste fest, welche 

Kommunikationskanäle deaktiviert werden, wenn der 

entsprechende Umschaltzustand aktiv ist. 

4.9.1 Variablenadapter bearbeiten 

Variablenadapter werden im Projektexplorer unter dem gleichnamigen Knoten dargestellt. 

Jede Variablenadapterdefinition beinhaltet: 

• einen editierbaren Parametersatz: Hier wird der Name festgelegt. Außerdem wird über 

die Definition von Umschaltzuständen bestimmt, zu welchen Werten der Adapter 

konfiguriert werden kann. 

• die Variablenzuordnung: Über eine Zuordnungstabelle werden Variablensätze 

projektiert. Jeder Variablensatz beinhaltet einen Alias und ein Feld für jeden 

Umschaltzustand. Über den Alias wird der Variablensatz an Steuerelemente 

angebunden. In den Feldern der Umschaltzustände wird eingetragen, welche Variable 

zum Alias umgelenkt wird. 

Der Editor bietet folgende Funktionen zum Projektieren von Variablenadaptern: 

Neu erzeugen Über Eintrag "Neu" im Kontextmenü des Knotens 

"Variablenadapter". 

Parameter 

bearbeiten 

Ein Klick auf einen Variablenadapter lädt die entsprechenden 




Variablenadapterknotens wird die Definition gelöscht. Dabei 

werden auch die enthaltenen Variablensätze gelöscht. 

Die Variablensätze im Tabelleneditor werden über den Parameter "Umschaltzustände" 

des Variablenadapters parametriert. Jeder neu hinzugefügte Umschaltzustand erweitert 

die Variablensatztabelle um eine entsprechende Spalte. Hier werden die Variablen 

eingetragen, die zur Laufzeit über den projektierten Alias angesprochen werden. 

Variablensätze werden über die Funktionen im Kontextmenü des Tabelleneditors als 

Tabellenzeilen neu eingefügt oder gelöscht. 

Im Knoten Variablen→Variablenadapter→Konfiguration wird für jeden Variablenadapter 

der aktive Umschaltzustand festgelegt.


Definitionen der Prozessanbindung / Variablenadapter / Beispiel Variablenadapter 72 

4.9.2 Beispiel Variablenadapter 

Das Beispiel zeigt, wie eine Applikation zu erstellen ist, wenn alternativ zu einer S7- 

Anbindung (über einen VisiWin-Treiber) eine Allen Bradley-Steuerung (über einen OPC- 

Server) an die Applikation angeschlossen werden soll. Die Anbindung über den Treiber 

ist dabei zusätzlich durch Strukturen optimiert. 

Die Lösung 

Die Beispieldefinition zeigt eine Prozessvariable in der S7-Syntax: 

Die zugehörige Strukturdefinition (Der Datentyp der 

Prozessvariablen, der den blockweisen Datenaustausch über den 

Treiber ermöglicht) hat folgenden Aufbau: 

Die Anbindung eines Steuerelementes (VWItem-Eigenschaft) auf 

den "Temperature"-Wert einer S7-Steuerung hat dann den Namen 

"Ch1.DB3" 

Die Allen Bradley-Steuerung erwartet eine andere Syntax. Hier 

sind Strukturen unbekannt. Prozessvariablen werden direkt in der 

Prozessvariablentabelle über symbolische Namen angesprochen: 

Die Anbindung eines Steuerelementes auf den "Temperature"- 

Wert der Allen Bradley-Steuerung hat dann den Variablennamen 

"Ch1.Temperature" 

Die in der Applikation zu verwendenden "VWItem"- 

Eigenschaftenwerte sind für die beiden Steuerungen also nicht 

kompatibel. Auch die ItemID hat einen anderen Inhalt. Der 

Versuch, den Alias der Allen-Bradley-Prozessvariablen auf 

"DB3" zu ändern, wird spätestens beim Start des 

Projektes durch einen Fehler quittiert. Das Laufzeitsystem 

scheitert an der Strukturauflösung (durch spitze Klammern 

gekennzeichnet). Spätestens hier steht der Projekteur vor dem 

Problem, das Projekt zu duplizieren und alle kommenden 

Änderungen in zwei Projekten nachzupflegen. 

Beide Kanäle können innerhalb eines Projektes angelegt werden. Die Anpassung erfolgt 

mithilfe eines Variablenadapters. 

Die Prozessvariablen der Steuerungen S7 sind unter dem 

Kommunikationskanal "S7" anzulegen. Die Prozessvariablen für die 

Allen Bradley-Steuerung sind in einem zweiten 

Kommunikationskanal "AB" zu definieren. 

Über das Kontextmenü des Knoten "Variablenadapter" ist ein neuer 

Adapter anzulegen. 

Im Eigenschaftendialog des neuen Adapters sind folgende


Änderungen vorzunehmen: 

Parameter Wert 


Name AdaptS7_AB 

Umschaltzustände Hinzufügen eines Umschaltzustandes 

mit dem Namen "AB" 

zu deaktivierende 

Kanäle bei 

Standardeinstellung 

Der Umschaltzustand "Default" ist in der 

Liste der Umschaltzustände zu 

markieren, anschließend ist in der "zu 

deaktivierende Kanäle" der 

Kommunikationskanal "AB" 

anzukreuzen. 

Für den neu angelegten 

Umschaltzustand "AB" ist der Kanal "S7" 

zu deaktivieren. 

Der so erzeugte Adapter definiert eine Umschaltung von Variablen 

aus zwei unterschiedlichen Steuerungen. In den Eigenschaften 

wird zusätzlich angeboten, einen oder mehrere Kanäle für jeden 

Umschaltzustand zu deaktivieren. Die hier gewählten 

Kommunikationskanäle werden dann vom Laufzeitsystem nicht 

mehr angesprochen, wenn die entsprechende Konfiguration 

gewählt wurde.



Über den Knoten "AdaptS7_AB" ist zur entsprechenden Tabelle zu 

wechseln. 

Im Tabelleneditor ist auf die leere Tabelle zu klicken. 

Über den Eintrag "Variablensatz neu" des Kontextmenüs öffnet sich 

ein Auswahldialog, der das Einfügen mehrerer Prozessvariablen 

erlaubt. Hier sind die Variablen der ersten Umschaltvariante 

auszuwählen: 

Die Auswahl wird in die Tabelle des Adapters eingetragen, wobei 

aus dem Standardwert der Alias gebildet wird. 

Bei einem bestehenden Projekt, in dem Steuerelemente bereits mit 

Variablen verbunden sind, empfiehlt es sich, hier die bereits 

angebundenen Variablen auszuwählen. Die Applikation kann ohne 

Änderungen in den Steuerelementen über den Variablenadapter 

um eine zweite Steuerung erweitert werden. 

In der Tabelle sind über den Variablenauswahldialog in den 

Feldern des hinzugefügten Umschaltzustandes "AllenBradley" die 

alternativen Prozessvariablen der Allen Bradley-Steuerung 

einzutragen.



Der Alias stellt nun den Bezeichner dar, der in der Applikation als 

VWItem-Eigenschaft verwendet werden kann. Die Spalten 

"Standard" und "AllenBradley" geben die 

Prozessvariablendefinitionen an, die real verwendet werden. 

Abschließend ist zu klären, wie der Adapter konfiguriert wird, um 

zwischen den Zuständen "Standard" und "AllenBradley" 

umzuschalten. 

Der Knoten Variablen→Variablenadapter→Konfiguration ist im 

Projektexplorer zu markieren. In der VisiWinNET- 

Eigenschaftenseite ist in der Liste für den Variablenadapter 

"AdaptS7_AB" der Umschaltzustand "AB" zu wählen.



Die Auswahlliste des "aktiven Umschaltzustandes" beinhaltet die 

Standardkonfiguration ("Default") und zusätzlich alle selbst 

projektierten Umschaltzustände. 

Die Auswahl des "AB"-Umschaltzustandes aktiviert die 

Variablendefinitionen, die in der entsprechenden Spalte angegeben 

wurden. 

Das Laufzeitsystem behandelt die hier projektierten Informationen 

in folgenden Schritten: 

• Der aktive Umschaltzustand des Adapters wird gelesen 

• anhand der Informationen des aktiven Zustandes werden ggf. 

einzelne Kommunikationskanäle deaktiviert. Das 

Laufzeitsystem versucht erst gar nicht, eine Verbindung zu den 

entsprechenden Kommunikationskomponenten aufzunehmen. 

Dies verhindert das Auftreten von Fehlermeldungen, wenn die 

entsprechende Kommunikationskomponente oder der 

Anschluss an die SPS nicht vorhanden ist. 

• Für eine Variablenwertanforderung aus der Applikation 

überprüft der Variablenkern zuerst die Alias-Angaben der 

Variablensätze im Variablenadapter. Ist hier kein 

entsprechender Alias zu finden, wird die Variable direkt im 

Kommunikationskanal gesucht. Wird der Alias aber in der 

Tabelle gefunden, wird über den konfigurierten 

Umschaltzustand die tatsächlich angeforderte 

Variablendefinition ermittelt. Anschließend werden nach dem 

normalen Verfahren die Daten ausgetauscht.


Parameter der Definitionen der Prozessanbindung / Variablenadapter / Beispiel Variablenadapter 77 

5 Parameter der Definitionen der Prozessanbindung 

Im Folgenden eine alphabetische Auflistung der Parameter. Zusätzlich noch die Information, 

von welcher VisiWinNET-Produktvariante der Parameter unterstützt wird. 

Parametername VisiWinNET 

Standard 

Abtastzeit 

Adresse 

Aktivierungsmodus 

Alias 

Beschreibung 

Browser 

Browsereigenschaften 

Bytetausch 

Daten direkt aus der Hardware lesen 

Datentyp 

Definition aktiv 

Einheitenklasse (Anzeige) 

Einheitenklasse (Prozess) 

Einheitentext 

Einzeln beschreibbar 

Einzelzugriff auf Feldelemente 

Ersatzwert 

Ersatzwert Modus 

Feldgröße 

Fließkomma-konvertierung IEEE-S5/S7 

Hysterese 

ItemID 

Kommaverschiebung 

Kommentar 

Konfiguration im OPC-Server-Projekt 

speichern 

Konfigurationsstatus 

Lesen wiederholen bei Schreib- 

/Lesekonflikt 

VisiWinNET 

Compact 

VisiWinNET 

Embedded


Lesezugriffe 

Maximalwert 

Minimalwert 

Name 

nur Data-Callback-Interface V1.0 

benutzen 

OPC-Servername 

OPC-Server hat Unicode-Strings 

OPC-Shutdown-Interface nicht 

verbinden 

Ordnungsnummer 

Ordnungsnummer als Byteoffset 

Rechnername 

Schreibzugriffe 

Separatorzeichen 

Sicherheit 

Standardsprache 

Startwerte nicht synchron einlesen 

Steuerobjekt 

Strukturzugriff 

Synchrone Kommunikation ermöglichen 

Text 

Treibername 

Umschaltkennung 

Umschaltvariable 

Umschaltzustände 

URL 

Variablenoptionen 

Variablen beim Deaktivieren weiterlesen 

Variablen statisch aktivieren 

Variablenwerte bei OPC Quality BAD 


Verbindungsversuche nach 

Initialisierungsphase wiederholen 

Version 

Parameter der Definitionen der Prozessanbindung / Variablenadapter / Beispiel Variablenadapter 78


VWE erzeugt Items (CallR-Server) 

Worttausch VT_I4, VT_UI4 

Worttausch VT_R4, VT_R8 

x1 

x2 

y1 

y2 

Zeitzonendifferenz 

zu deaktivierende Kanäle 

Zugriffsart 

Zugriffspfad 

5.1 Abtastzeit 

Parameter für Gruppe 

Parameter der Definitionen der Prozessanbindung / Abtastzeit / Beispiel Variablenadapter 79 

Beschreibung Die Abtastzeit bestimmt, wie oft die Kommunikationskomponente 

geänderte Werte von Prozessvariablen in dieser Gruppe an den 

Variablenkern zurückgibt. Wird die Abtastzeit kleiner eingestellt, 

als die Zykluszeit der Kommunikationskomponente, so werden die 

Daten im Zyklus der Kommunikationskomponente zurückgegeben 

(da eine Änderung maximal im Zyklus des OPC-Servers auftreten 

kann). Sinnvoll ist die Einstellung jedoch, wenn die Abtastzeit ein 

vielfaches der Zykluszeit der Kommunikationskomponente ist, 

insbesondere, wenn eine schnelle Anzeige in der Applikation nicht 

benötigt wird. In diesem Fall werden geänderte Werte aus der 

Kommunikationskomponente in der eingestellten Abtastzeit an den 

Variablenkern zurückgemeldet. Dies führt zu einem reduzierten 

Datenaufkommen zwischen Kommunikationskomponente und 

Variablenkern.


5.2 Adresse 

Parameter für Prozessvariable (VisiWin-Treiber) 

Parameter der Definitionen der Prozessanbindung / Adresse / Beispiel Variablenadapter 80 

Beschreibung Beschreibt den Zugriff auf den Prozesswert in einem VisiWin- 

Treiber. VisiWin-Treiber kommunizieren über die Angabe der 

Speicheradresse mit einer SPS. 

Der Aufbau der Adressangabe ist abhängig von der verwendeten 

Steuerung. 

Beispiel (für eine Adressangabe bei Siemens S5) 

Bei einer Siemens S5-Steuerung sollen fünf Datenworte des 

Datenbausteins 20 ab Adresse 2 eingelesen werden.


5.3 Aktivierungsmodus 

5.4 Alias 


Parameter der Definitionen der Prozessanbindung / Aktivierungsmodus / Beispiel Variablenadapter 81 

Beschreibung Bestimmt, wann Daten zwischen Kommunikationskomponente und 

Variablenkern ausgetauscht werden. 

Einstellung Beschreibung 

automatisch Der Austausch der Daten wird durch die 

Anforderung einer 

Visualisierungsapplikation oder eines 

Systemservers (z.B. Alarmserver) an den 

Variablenkern automatisch aktiviert. 

Visualisierungsapplikationen melden 

Prozessvariablen zum Datenaustausch an, 

wenn z.B. ein Formular geladen wird, auf 

dem Variablenwerte angezeigt werden. 

Wird das Formular entladen, werden die 

Anmeldungen der entsprechenden 

angebundenen Prozessvariablen beim 

Variablenkern zurückgenommen. Damit 

wird auch der Datenaustausch gestoppt. 

Systemserver fordern üblicherweise die 

Aktivierung des Datenaustausch zu 

kontinuierlichen Überwachungszwecken 

direkt nach der Initialisierung an. Solange 

ein Systemserver läuft, bleibt der 

Datenaustausch der angeforderten 

Prozessvariablen aktiv. 

Trigger Der Datentransfer wird über die den 

Zustand einer Variablen gesteuert (Siehe 

auch Parameter "Steuerobjekt"). 

Anwendungsgesteuert 

Parameter für Prozessvariable 

Der Datentransfer wird über Aufrufe aus 

den Visualisierungsapplikationen (Siehe 

auch Parameter "Steuerobjekt") gesteuert. 

immer Sobald der Variablenkernel initialisiert 

wurde, beginnt der Datentransfer. 

Die Einstellungen "Trigger" und "Anwendungsgesteuert" stehen in 

der "Compact"-Laufzeit nicht zur Verfügung 

Beschreibung Bezeichnet das Objekt in der Visualisierungsapplikation und im 

Variablenkern. Der Alias wird z.B. in der Eigenschaft VWItem der 

VisiWinNET-Steuerelemente als Bezug zur Prozessvariablen 

genutzt.


5.5 Beschreibung 

5.6 Browser 

Parameter der Definitionen der Prozessanbindung / Beschreibung / Beispiel Variablenadapter 82 

Parameter für Kommunikationskanal (OPC-Server), Kommunikationskanal 

(VisiWin-Treiber) 

Beschreibung Gibt einen beschreibenden Text der Kommunikationskomponente 

an. Die Beschreibung ist nicht editierbar. Sie wird automatisch von 

VisiWinNET beim Einsetzen einer ProgID ermittelt. Sie beschreibt 

in lesbarer Form die Kommunikationskomponente. Die 

Beschreibung wird im Projektexplorer zusätzlich zum 

Kommunikationskanalnamen angezeigt. 

Parameter für Kommunikationskanal 

Beschreibung Legt die spezifische Komponente zum Lesen von 

Variablendefinitionen aus Projektdateien, der SPS oder anderen 

Quellen fest. 

Nach dem Einfügen eines neuen Kanals wird der "Browser"- 

Parameter auf einen Kommunikationskomponenten-spezifischen 

Wert gesetzt, d.h. ist ein Browser für die 

Kommunikationskomponente verfügbar, wird dieser auch direkt 

eingetragen. 

Variableninformationen, wie z.B. die ItemID sind stark abhängig 

von der verwendeten Kommunikationskomponente. Änderungen 

an dem "Browser"-Parameter und damit das Browsen von Daten 

aus einer anderen Kommunikationskomponente erfordern genaue 

Kenntnisse über die erforderlichen syntaktischen Informationen in 

den unterschiedlichen Kommunikationskomponenten. 

Soll der Browser also trotzdem gezielt umgelenkt werden, kann 

über die -Schaltfläche ein Browser über einen Auswahldialog 

ausgewählt werden. 

Quasi als Standard installiert ist immer der Browser für OPC- 

Server "VisiWinNET.Opc.Brw.dll". Weitere aufgelistete Browser 

werden üblicherweise durch die Installation einer 

Kommunikationskomponente entsprechend registriert und im 

Dialog angezeigt.


Parameter der Definitionen der Prozessanbindung / Browser / Beispiel Variablenadapter 83 

Ein Browser ist ein einfach zu bedienenden Dialog, der die 

öffentlichen Variablen einer Steuerung oder eines SPS- 

Programmes anzeigt. Geöffnet wird der Browserdialog über das 

Kontextmenü eines Kommunikationskanals. Durch die Auswahl 

einzelner Variablen auf dem Dialog werden die Prozessgrößen 

markiert, die für die Visualisierung relevante Informationen 

beinhalten. Nach der Übernahme der Daten aus dem Browserdialog 

werden die entsprechenden Variableninformationen (Zugriff, 

Datentyp, Alias, ...) in die Projektdatenbank der Visualisierung 

geschrieben. 

Danach stehen sie zur Verfügung, um in Steuerelementen oder 

zusätzliche Funktionen, wie z.B..Alarmen angebunden zu werden. 

Die Fähigkeit, Variablen über einen Browserdialog abrufen zu 

können, hängt von verschiedenen Faktoren ab: 

Unterstützt die Kommunikationskomponente das Browsen? 

• OPC-Server beinhalten per Spezifikation eine 

Browserschnittstelle. Im Allgemeinen sollten also 

Variableninformationen zu browsen sein. 

• Für bestimmte VisiWinNET-Treiber wird eine zusätzliche 

Komponente angeboten, die das Browsen von 

Variableninformationen über SPS-spezifische Projektdateien 

erlauben. 

• VisiWin-Treiber beinhalten im allgemeinen keine 

Browserschnittstelle. 

Woher kommen die Daten? 

• Aus den Quellen des SPS-Programms. 

• Aus speziell exportierten Listen 

• Aus der angeschlossenen Steuerung 

• Aus einer Projektdatei, die von der 

Kommunikationskomponente verwaltet wird (OPC-Server) 

• Aus dem Visualisierungsprogramm (CallR-Server) 

Auf jeden Fall sind für die erfolgreiche Datenübernahme aus dem 

Browser die Randbedingungen zu klären. Daher ist die Lektüre der 

spezifischen Dokumentation unabdingbar. 

Einige Browser erfordern für die Datenübernahme weitere 

Konfigurationsschritte. Browser, die von der INOSOFT erstellt 

wurden, können über den Parameter "Browsereigenschaften" 

konfiguriert werden. 

Der Standard OPC-Browser "VisiWinNET.Opc.Brw.dll" hinterlegt 

hier z.B. den Namen des OPC-Servers.


5.7 Browsereigenschaften 


Parameter der Definitionen der Prozessanbindung / Browsereigenschaften / Beispiel Variablenadapter 84 

Beschreibung Beinhaltet Informationen, die der Browser zum Lesen von 

Variableninformationen benötigt. Die über "Browser" festgelegte 

Browse-Komponente hat hier die Möglichkeit, eigene 

Konfigurationseinstellungen abzuspeichern. Sowohl das Format als 

auch die Darstellung über einen Dialog sind individuelle Merkmale 

der Browser-Komponente. Eine Beschreibung ist daher der 

entsprechenden Dokumentation zu entnehmen. 

Hinterlegt die Browser-Komponente also ihre Konfigurationswerte 

in diesem Feld, kann über die -Schaltfläche der entsprechende 

Konfigurationsdialog aufgerufen werden. 

Der Standard OPC-Browser "VisiWinNET.Opc.Brw.dll" hinterlegt 

hier z.B. den Namen des OPC-Servers. Über die -Schaltfläche 

kann ein anderer OPC-Server ausgewählt werden.


5.8 Bytetausch 

Parameter für Kommunikationskanal (OPC-Server) 

Parameter der Definitionen der Prozessanbindung / Bytetausch / Beispiel Variablenadapter 85 

Beschreibung Der Aufbau von Prozesswerten in der SPS ist für jeden SPS-Typ 

individuell. So kann es vorkommen, dass einzelne Datentypen 

unterschiedlich aufgebaut sind. Beim Austausch von einzelnen 

Prozessvariablenwerten wird die Anpassung zur Visualisierung 

üblicherweise von der Kommunikationskomponente ausgeführt. 

Wird über eine Struktur blockweise (über eine Prozessvariable, die 

den Datentyp einer Struktur hat) "als Bytestream" (→Parameter 

"Strukturzugriff") auf Daten der SPS zugegriffen, kann die 

Kommunikationskomponente diese Anpassung nicht mehr 

ausführen, da Sie über den Aufbau des Byteblocks nicht informiert 

ist. Daher muss im Variablenkern diese Anpassung erfolgen. 

Der Parameter "Bytetausch" bewirkt, dass die jeweils zwei 

aufeinander folgenden Bytes eines als Bytestream übertragenen 

Byteblocks miteinander getauscht werden. 


True Beim Lesen aus der SPS wird vom Variablenkern ein 

Byteblock über die Kommunikationskomponente 

angefordert. Nach Erhalt des Blocks werden jeweils 

zwei aufeinander folgende Bytes getauscht. Erst dann 

wird der interne Prozessvariablencache gemäß dem 

Aufbau der Struktur mit den Bytes des empfangenen 

Blocks gefüllt. 

Beim Schreiben wird ein Byteblock gemäß den 

Angaben der Struktur aus dem internen 

Prozessvariablencache zusammengestellt. Danach 

werden die jeweils zwei aufeinanderfolgenden Bytes 

getauscht. Anschließend wird der Block zur SPS 

übertragen.


Parameter der Definitionen der Prozessanbindung / Daten direkt aus der Hardware lesen / Beispiel Variablenadapter 86 

False Beim Lesen aus der SPS wird vom Variablenkern ein 


angefordert. Der interne Prozessvariablencache wird 

ohne Bytetausch gemäß dem Aufbau der Struktur mit 

den Bytes des empfangenen Blocks gefüllt. 



Prozessvariablencache zusammengestellt. Danach wird 

dieser Block direkt zur SPS übertragen. 

Die Verwendung des Parameters "Bytetausch" ist abhängig von der 

verwendeten SPS. Sie ist nur sinnvoll, wenn der Parameter 

"Strukturzugriff" auf "als Bytestream" eingestellt ist und Strukturen 

als Datentypen für Prozessvariablen verwendet werden. 

Weitere Anpassungsmöglichkeiten für diese Zugriffsart: 

→Parameter "Fließkomma-Konvertierung IEEE-S5/S7" 

→Parameter "Worttausch VT_R4, VT_R8" 

→Parameter "Worttausch VT_I4, VT_UI4" 

→Parameter "OPC-Server hat Unicode-Strings" 

5.9 Daten direkt aus der Hardware lesen 

Dieser Parameter wird von der "Compact"-Produktvariante nicht 

unterstützt. 


Beschreibung Bestimmt beim synchronen Lesen, ob der OPC-Server die Werte 

aus dem internen Prozessvariablencache oder direkt aus der 

Hardware lesen soll. 


True Der OPC-Server spricht nach der Leseanforderung zum 

nächstmöglichen Zeitpunkt die Hardware an, um den 

angeforderten Prozesswert zu lesen. 

False Der OPC-Server übergibt den Prozesswert aus seinem 

internen Prozessvariablencache.


5.10 Datentyp 

Parameter für Prozessvariable, Strukturelement 

Parameter der Definitionen der Prozessanbindung / Datentyp / Beispiel Variablenadapter 87 

Beschreibung Bestimmt den Aufbau und die Länge der Prozessvariablen. Im 

Parameter "Datentyp" kann entweder ein einfacher Datentyp oder 

der Name einer in VisiWinNET definierten Struktur eingegeben 

werden. 

Datentypen Einstellung Wert Beschreibung 

VT_I2 2 Ganzzahliger Wert (2 Byte) 

VT_I4 3 Ganzzahliger Wert (4 Byte) 

VT_R4 4 Fließkommazahl (4 Byte) 

VT_R8 5 Fließkommazahl (8 Byte) 

VT_DATE 7 Datumsformat 

VT_BSTR 8 Text von der Länge der im Parameter 

"Feldgröße" eingestellten Anzahl 

VT_BOOL 11 Boolean-Wert 

VT_VARIANT Variant-Datentyp 

VT_I1 16 1 Byte vorzeichenbehaftet 

VT_UI1 17 1 Byte vorzeichenlos 



VT_BIT 256 Hilfsdatentyp zum Zugriff auf einzelne 

Bits in einer Strukturdefinition, die den 

Parameter "Ordnungsnummer als 

Byteoffset" aktiviert hat. In der 

Ordnungsnummer wird bei der Wahl 

dieses Datentyps eine erweiterte 

Beschreibung des Offsets erwartet: 

Die Vorkommastelle dient weiterhin zur 

Festlegung des Byteoffsets in der 

Struktur. Die Nachkommastelle gibt 0indiziert 

das gewünschte Bit an. 

 

- Name einer Strukturdefinition


5.11 Definition aktiv 

Parameter der Definitionen der Prozessanbindung / Definition aktiv / Beispiel Variablenadapter 88 

Parameter für Gruppe, Prozessvariable, Kommunikationskanal (OPC-Server), 

Kommunikationskanal (VisiWin-Treiber), Variablenadapter 

Beschreibung Beschreibt, ob die Objektdefinition gültig ist. Wird der Parameter 

deaktiviert, so wird beim Programmstart die Objektdefinition vom 

Variablenkern ignoriert. 

5.12 Einheitenklasse (Anzeige) 


Beschreibung Verweist auf eine sprach- oder variablenabhängige 

Einheitenklasse. 

Die hier angegebene Umrechnung wird zwischen Applikation und 

Variablenkern vorgenommen, d.h. in einem Client-Server-System 

ist die Umrechnung für jede Visualisierungsapplikation individuell 

einzustellen. 

5.13 Einheitenklasse (Prozess) 


Beschreibung Verweist auf eine variablenabhängige Umrechnungsformel. Bei 

einer Wertänderung der Variablen wird die entsprechende 

Gleichung der Einheitenklasse dazu genutzt, den 

Prozessvariablenwert beim Datenaustausch zwischen 

Variablenkern und Kommunikationskomponente umzurechnen. 

Diese Umrechnung ist insbesondere nützlich, wenn ohne 

Anpassung des SPS-Programms Maschinenteile ausgetauscht 

werden sollen (z.B. Tausch von Laufrollen unterschiedlicher Radien 

und Anzeige der Laufgeschwindigkeit in der Visualisierung). 

5.14 Einheitentext 

Parameter für Einheit 

Beschreibung Mit dem Parameter "Einheitentext" kann ein zusätzlicher Text 

angegeben werden, der zur Laufzeit an die Steuerelemente zur 

Anzeige übergeben wird und dort die physikalische Größe der 

Einheit beschreibt. 

Beginnt der Einheitentext mit einem "@"-Zeichen, wird der Wert 

als Bezeichner eines Indextextes interpretiert. In der Anzeige wird 

dann der entsprechende Text in der aktuell in der Applikation 

eingestellten Sprache zurückgegeben. Die Vergabe eines 

sprachabhängigen Einheitentextes ist dann sinnvoll, wenn eine 

Einheit über eine Variable umgeschaltet werden soll und zusätzlich 

die textuelle Angabe sprachabhängig ist. 

Der hier projektierte Text hat keinerlei Funktionen in der 

Einheitenumrechnung zwischen Variablenkern und 

Kommunikationskomponente (Einheitenklasse (Prozess)).


5.15 Einzeln beschreibbar 


Parameter der Definitionen der Prozessanbindung / Einzeln beschreibbar / Beispiel Variablenadapter 89 

Beschreibung Der Parameter "Einzeln beschreibbar" bestimmt, ob nach dem 

schreibende Zugriff auf ein Feld- oder Strukturelement die neuen 

Daten sofort zur Kommunikationskomponente übertragen werden. 


True Der Datentransfer zur Kommunikationskomponente 

wird im Variablenkern direkt nach dem schreibenden 

Zugriff auf ein Struktur-/Feldelement ausgelöst. 

False Der Datentransfer zur Kommunikationskomponente 

wird im Variablenkern wird erst ausgelöst, nachdem 

der Datentransfer für das gesamte Feld ausgelöst 

wurde. Dies ist zum Beispiel dadurch möglich, dass die 

Prozessvariable in einer Gruppe ist, die durch einen 

Trigger explizit den Schreibauftrag zur 

Kommunikationskomponente schickt (siehe auch 

Parameter "Steuerobjekt" 


unterstützt.


5.16 Einzelzugriff auf Feldelemente 


Parameter der Definitionen der Prozessanbindung / Einzelzugriff auf Feldelemente / Beispiel Variablenadapter 90 

Beschreibung Der Parameter "Einzelzugriff auf Feldelemente" bestimmt, ob der 

schreibende Zugriff auf ein Feld- oder Strukturelement das 

gesamte Feld/die gesamte Struktur auf die 

Kommunikationskomponente zurückschreibt. 


True Nur das geänderte Feld-/Strukturelement wird 

zurückgeschrieben. 

False Der gesamte durch die Struktur/das Feld definierte 

Speicherblock wird auf die SPS zurückgeschrieben. 

VisiWin-Treiber: Schreibende Zugriffe auf Struktur-/Feldelemente 

werden immer unterstützt. 

OPC-Server: Das Schreiben von einzelnen Struktur-/Feldelementen 

muss vom OPC-Server unterstützt werden. Ob der benutzte OPC- 

Server diese Funktion unterstützt, ist aus der OPC-Server- 

Dokumentation zu entnehmen. 


unterstützt.


5.17 Ersatzwert 


Parameter der Definitionen der Prozessanbindung / Ersatzwert / Beispiel Variablenadapter 91 

Beschreibung Gibt den Wert an, der in den durch den Parameter "Ersatzwert 

Modus" beschriebenen Fällen anstelle des realen 

Prozessvariablenwertes übertragen wird. 

Der Ersatzwert lässt sich in verschiedenen Szenarien verwenden: 

Datentyp String 

Standardwert "" 

• Wird der Ersatzwert beim Start in eine Prozessvariable 

eingetragen, kann damit ein Variableninitialisierung realisiert 

werden. 

• Im Fall einer Verbindungsunterbrechung zur SPS kann ein 

entsprechender Ersatzwert einen Fehler signalisieren 

• Wird der Ersatzwert beim Beenden der Applikation gesendet, 

kann die SPS entsprechend reagieren.


5.18 Ersatzwert Modus 


Parameter der Definitionen der Prozessanbindung / Ersatzwert Modus / Beispiel Variablenadapter 92 

Beschreibung In bestimmten Fällen ist es möglich, anstelle des wahren 

Prozessvariablenwert einen Ersatzwert zu übertragen. Der 

"Ersatzwert Modus" beschreibt, wohin und in welchen Fällen der 

Ersatzwert (Kap.: 5.17) anstelle des wahren 

Prozessvariablenwertes übertragen wird. 

Die Einstellungen beschreiben gemeinsam den 

Übertagungszeitpunkt und das Übertragungsziel für den 

Ersatzwert. 

Übertragungs- 

zeitpunkt 


Beim Start senden Der Ersatzwert wird beim Start des 

Variablenkerns geschrieben. Dies kann 

zum Initialisieren einer Prozessvariablen 

dienen. 

Bei Kommunikations- 

abbruch senden 

Der Ersatzwert wird bei einer 

Kommunikationsstörung in die 

Prozessvariable im Variablenkern 

geschrieben. Die Übertragung an den 

OPC-Server hat hier keine Funktion (da 

die Prozessvariable im OPC-Server bei 

einer Kommunikationsstörung nicht 

beschrieben werden kann). 

Beim Beenden senden Der Ersatzwert wird beim Beenden des 

Variablenkerns in die Prozessvariable im 

OPC-Server geschrieben. Dies kann als 

Nachricht an die SPS genutzt werden, 

dass alle Visualisierungsapplikationen 

beendet worden sind. Eine Übertragung 

des Ersatzwertes in die Prozessvariable 

im Variablenkern ist nicht vorgesehen, da 

dieser gerade beendet wurde, das "I"-Bit 

hat also keine Funktion. 

Übertragungsziel In Variable eintragen Der Ersatzwert wird zum 

Übertragungszeitpunkt in die 

Prozessvariable im Variablenkern 

geschrieben. Applikationssteuerelemente 

zeigen in diesem Fall den Ersatzwert an. 

An den Quell-OPC- 

Server senden 

Der Ersatzwert wird zum festgelegten 

Übertragungszeitpunkt in die 


geschrieben.


5.19 Feldgröße 


Parameter der Definitionen der Prozessanbindung / Feldgröße / Beispiel Variablenadapter 93 

Beschreibung Anzahl der Datenzellen des definierten Datentyps. 

Die Feldgröße ermöglicht den blockweisen Zugriff auf einen 

Speicherbereich, der eine Folge von Daten gleichen Typs 

beinhaltet. Als Vorgabe ist im Parameter "Feldgröße" der Wert "0" 

angegeben, d.h. es wird eine einzelne Prozessvariable angefordert. 

Werte >"0" definieren den Zugriff auf ein Datenfeld. Bezüge auf 

ein Element eines Datenfeldes werden in VisiWinNET nach 

folgender Syntax definiert: 

Kommunikationskanalname.VariableName. 

Beispiel: Das erste Element der Prozessvariablen "arr0" (Feldgröße 

= 5) im Kommunikationskanal "Ch1" soll in einem VarOut- 

Steuerelement angezeigt werden: 

Der Eigenschaftenseite der Eigenschaft "VWItem" ermöglicht die 

Auswahl dieser Prozessvariablen. Als Wert wird in die Eigenschaft 

folgender Variablenbezeichner übertragen: 

Ch1.arr0. 

Der Zugriff auf Feldelemente erfolgt 0-indiziert (das erste Feld hat 

also den Index 0). 

Feldindizes werden in eckigen Klammern dargestellt. 

VisiWin-spezifische Variablenbezeichner werden in spitze 

Klammern eingefasst.


Parameter der Definitionen der Prozessanbindung / Fließkomma-Konvertierung IEEE-S5/S7 / Beispiel Variablenadapter 94 

5.20 Fließkomma-Konvertierung IEEE-S5/S7 













Der Parameter "Fließkomma-Konvertierung IEEE-S5/S7" bewirkt, 

dass Strukturelemente vom Datentyp VT_R4/VT_R8 in einem 

übertragenen Byteblock in ein gültiges Format konvertiert werden. 





gemäß dem Aufbau der Struktur mit den Bytes des 

empfangenen Blocks gefüllt. Ist ein angesprochenes 

Strukturelement dabei vom Datentyp VT_R4 /VT_R8, 

so wird die Fließkommazahl vom SPS-spezifischen 

IEEE-Format in ein für die Visualisierung 

verständliches Format gewandelt. 



Prozessvariablencache zusammengestellt. Dabei 

überprüft der Variablenkern, ob ein Strukturelement 

den Datentyp VT_R4/VT_R8 einnimmt. Ist dies der Fall, 

wird der Wert aus dem internen Prozessvariablencache 

in das SPS-spezifische IEEE-Format gewandelt. 

Anschließend wird der Block zur SPS übertragen. 




ohne weitere Anpassungen gemäß dem Aufbau der 

Struktur mit den Bytes des empfangenen Blocks gefüllt. 




dieser Block direkt zur SPS übertragen.


5.21 Hysterese 

5.22 ItemID 


Parameter der Definitionen der Prozessanbindung / Hysterese / Beispiel Variablenadapter 95 

Die Verwendung des Parameters "Fließkomma-Konvertierung 

IEEE-S5/S7" ist abhängig von der verwendeten SPS. Sie ist nur 

sinnvoll, wenn der Parameter "Strukturzugriff" auf "als Bytestream" 

eingestellt ist und Strukturen als Datentypen für Prozessvariablen 

verwendet werden. 


→Parameter "Bytetausch 





unterstützt. 

Beschreibung Die Hysterese gibt an, um wie viel Prozent sich ein 

Prozessvariablenwert in der Kommunikationskomponente ändern 

muss, damit er als geändert an den Variablenkern zurückgesendet 

wird. Der Parameter "Hysterese" hat nur eine Bedeutung, wenn der 

Parameter "Aktivierungsmodus" auf "automatisch" eingestellt ist. 

Parameter für Prozessvariable (OPC-Server) 

Beschreibung Identifiziert die Prozessvariable im OPC-Server. Der Zugriff auf 

eine Prozessvariable im OPC-Server erfolgt über die ItemID.


5.23 Kommaverschiebung 


Parameter der Definitionen der Prozessanbindung / Kommaverschiebung / Beispiel Variablenadapter 96 

Beschreibung Bei der Verwendung von Fließkommazahlen gibt die 

Kommaverschiebung die Anzahl der Nachkommastellen an. 

Bei der Verwendung von ganzzahligen Datentypen ist es über die 

Kommaverschiebung möglich, in den VisiWinNET- 

Steuerelementen ganzzahlige Werte als Fließkommazahlen 

darzustellen. Der Prozessvariablenwert wird um die angegebene 

Stellenanzahl nach rechts verschoben. 

Beispiel: 

5.24 Kommentar 

Eine Prozessvariable gibt als Messwert eine Länge in "µm" an. Die 

im Maschinebau gebräuchliche Einheit "mm" soll in der 

Visualisierung als Einheit eines Eingabesteuerelementes angezeigt 

werden. Über den Wert "3" für die Kommaverschiebung wird der 

aus der SPS gelesene Wert als Fließkommazahl mit 3 

Nachkommastellen angezeigt. Der Wert wird also durch 1000 

geteilt. Beim schreibenden Zugriff, also nach einer Eingabe in das 

Steuerelement wird der Wert mit 1000 multipliziert, also wieder 

zurückgerechnet in das vom SPS genutzte Format. 

Parameter für Einheitenklasse (sprachabhängig), Einheitenklasse 

(variablenabhängig), Gruppe, Prozessvariable, 

Kommunikationskanal (OPC-Server), Kommunikationskanal 

(VisiWin-Treiber), Multiplexer, Struktur, Strukturelement, 

Variablenadapter 

Beschreibung Über den Kommentar ist der Projekteur in der Lage, Bemerkungen 

zu den Definitionen zu verfassen. Der Kommentar hat zur Laufzeit 

des Projektes keine Funktion. 


Standardwert ""


5.25 Konfigurationsstatus 

Parameter der Definitionen der Prozessanbindung / Konfigurationsstatus / Beispiel Variablenadapter 97 


(VisiWin-Treiber) 

Beschreibung Gibt an, ob ein Konfigurationsdialog aus der 

Entwicklungsoberfläche zu starten ist und ob die 

Kommunikationskomponente bereits konfiguriert wurde. 


kein 

Konfiguator 

vorhanden 

Konfiguator 

vorhanden 

bereits 

konfiguriert 

5.26 Konfiguration im OPC-Server speichern 


Es ist kein Konfigurationstool vorhanden, das 

aus der Entwicklungsumgebung zu starten ist. 

Dies ist insbesondere der Fall, wenn ein OPC- 

Server eines Fremdherstellers als 

Kommunikationskomponente ausgewählt wurde. 

Ein Konfigurationsdialog kann über den 

Menüeintrag "Konfigurieren" geöffnet werden. 

Die dort möglichen Einstellungen sind von der 

gewählten Kommunikationskomponente 

abhängig. Weitere Informationen über das 

Konfigurieren von OPC-Servern und VisiWin- 

Treibern finden sich in den entsprechenden 

Handbüchern. 

Die Kommunikationskomponente ist bereits 

konfiguriert worden. 

Beschreibung Gibt an, ob die Konfiguration eines INOSOFT OPC-Server im 

VisiWin-Projekt oder im OPC-Server-Projekt gespeichert wird. 

Ist diese Option aktiviert, verwaltet der INOSOFT OPC-Server 

seine Konfigurationsdaten eigenständig. Dies ist insbesondere 

dann sinnvoll, wenn der OPC-Server von einem Client gestartet 

wird, der kein VisiWin-Projekt ist.


Parameter der Definitionen der Prozessanbindung / Lesen wiederholen bei Schreib-/ Lesekonflikt / Beispiel Variablenadapter 98 

5.27 Lesen wiederholen bei Schreib-/ Lesekonflikt 


Beschreibung Wird innerhalb eines Zyklus zuerst (z.B. aus der Applikation) 

schreibend auf Eine Prozessvariable zugegriffen und empfängt der 

Variablenkern danach von der Kommunikationskomponente eine 

asynchrone Wertänderung, wird diese Wertänderung nicht 

automatisch an die Applikation bzw. an die beteiligten 

Serverkomponenten weitergereicht. Dies kann zu Datenverlusten 

führen. Über die Aktivierung des Parameters "Lesen wiederholen 

bei Schreib-/ Lesekonflikt" wird explizit eine neue Leseanforderung 

an die Kommunikationskomponente versendet, nachdem ein 

Schreibaufruf abgearbeitet wurde. 


True Nach dem Schreiben des neuen Prozessvariablenwertes 

wird automatisch eine neue Leseanforderung an die 

Kommunikationskomponente versendet. 

False Es wird keine neue Leseanforderung nach dem 

Schreiben des neuen Prozessvariablenwertes 

versendet.


5.28 Lesezugriffe 


Parameter der Definitionen der Prozessanbindung / Lesezugriffe / Beispiel Variablenadapter 99 

Beschreibung Bestimmt, ob der lesende Zugriff auf Prozessvariablen dieser 

Gruppe der Kommunikationskomponente synchron oder asynchron 

erfolgen soll. 

5.29 Maximalwert 


synchron Der Variablenkern reicht eine Leseanforderung 

an die Kommunikationskomponente weiter und 

wartet, bis der Prozessvariablenwert 

zurückgegeben wird. Das synchrone Lesen 

erhöht die Datenkonsistenz im Variablenkern, 

da nach der Anfrage auf jeden Fall gewartet 

wird, bis der Prozessvariablenwert 

zurückgegeben wird. Nachteilig wirkt sich 

jedoch aus, dass unter Umständen das gesamte 

System auf die Rückgabe des 

Prozessvariablenwertes warten muss, wenn die 

Kommunikationskomponente die Daten nicht 

schnell genug zurückgibt. 

asynchron Der Variablenkern schickt eine Anforderung 

zum Lesen eines Prozessvariablenwertes an die 

Kommunikationskomponente. Nach der 

Bearbeitung der Leseanforderung schickt die 

Kommunikationskomponente eine Nachricht, die 

den Prozessvariablenwert enthält, an den 

Variablenkern. Der Vorteil ist, dass der 

Variablenkern zwischen Anforderung und 

Nachricht weiter arbeitet. 

Für Prozessvariablen aus VisiWin-Treibern hat diese Einstellung 

nur eine Funktion, wenn der Parameter "Synchrone 

Kommunikation ermöglichen" aktiviert ist. Ansonsten werden die 

Variablenanforderungen asynchron ausgeführt. 


Beschreibung Über die Angabe eines Maximalwertes kann die Überschreitung 

eines Grenzwertes in der Applikation angezeigt werden. Die 

Übertragung von Prozessvariablen vom OPC-Server zum 

Variablenkern beinhaltet neben dem reinen Prozessvariablenwert 

zusätzliche Informationen, unter anderem auch ein sogenanntes 

"Quality-Flag". Hier wird zur Laufzeit die Überschreitung des 

Maximalwertes angezeigt. Die VisiWinNET-Steuerelemente 

empfangen das QualityFlag zur Laufzeit im Change-Ereignis, 

sodass eine Anzeige einer Maximalwertüberschreitung 

projektierbar ist. 

Werden die Parameter "Maximalwert" und "Minimalwert" auf den 

Wert "0" gestellt, so wird keine Grenzwertüberwachung 

durchgeführt.


5.30 Minimalwert 


Parameter der Definitionen der Prozessanbindung / Minimalwert / Beispiel Variablenadapter 100 

Beschreibung Über die Angabe eines Minimalwertes kann die Unterschreitung 

eines Grenzwertes in der Applikation angezeigt werden. Die 

Übertragung von Prozessvariablen vom OPC-Server zum 

Variablenkern beinhaltet neben dem reinen Prozessvariablenwert 

zusätzliche Informationen, unter anderem auch ein sogenanntes 

"Quality-Flag". Hier wird zur Laufzeit die Unterschreitung des 

Minimalwertes angezeigt. Die VisiWinNET-Steuerelemente 

empfangen das QualityFlag zur Laufzeit im Change-Ereignis, 

sodass eine Anzeige einer Minimalwertunterschreitung 

projektierbar ist. 

Werden die Parameter "Maximalwert" und "Minimalwert" auf den 

Wert "0" gestellt, so wird keine Grenzwertüberwachung 

durchgeführt.


5.31 Name 

Parameter der Definitionen der Prozessanbindung / Name / Beispiel Variablenadapter 101 

Parameter für Einheitenklasse (sprachabhängig), Einheitenklasse 

(variablenabhängig), Gruppe, Kommunikationskanal (OPC-Server), 

Kommunikationskanal (VisiWin-Treiber), Multiplexer, Struktur, 

Strukturelement, Variablenadapter 

Beschreibung Der Name benennt eine VisiWinNET-Definition eindeutig. 

Innerhalb einer VisiWinNET-Applikation wird ein Objekt über 

diesen Namen identifiziert. 

Objekt Namensvergabe 


Ein Kommunikationskanalname darf nur 

einmal in einer VisiWinNET-Applikation 

verwendet werden. 

Gruppe Ein Gruppenname darf nur einmal in einer 

VisiWinNET-Applikation verwendet werden. 

Prozessvariable Ein Prozessvariablenname darf nur einmal in 

einem Kommunikationskanal verwendet 

werden. Der Zugriff auf eine Prozessvariable 

in der Applikation erfolgt immer mit der 

Angabe des Kommunikationskanalnamens. 

Struktur Ein Strukturname darf nur einmal in einer 

VisiWinNET-Applikation verwendet werden. 

Der Strukturname wird von den 

Prozessvariablendefinitionen als 

Datentypbezeichnung verwendet. 

Strukturelement Ein Strukturelementename darf nur einmal 

in einer Struktur verwendet werden. Der 

Zugriff auf ein Strukturelement erfolgt über 

die Zusammensetzung aus 

Kommunikationskanal-, Prozessvariablen- 

und Strukturelementenamen. Da eine 

Prozessvariable nur vom Typ einer einzigen 

Struktur sein kann, ist das entsprechende 

Strukturelement eindeutig. 

Einheitenklasse Ein Einheitenklassenname darf nur einmal in 

einer VisiWinNET-Applikation verwendet 

werden. Der Name der Einheitenklasse 

spezifiziert in den Prozessvariablen die 

Umrechnung.


Parameter der Definitionen der Prozessanbindung / nur Data-Callback-Interface V1.0 benutzen / Beispiel Variablenadapter 102 

5.32 nur Data-Callback-Interface V1.0 benutzen 


Beschreibung Der Parameter "nur Data-Callback-Interface V1.0 benutzen" 

bestimmt, wie der Variablenkern die Verbindung zum OPC-Server 

aufbaut. 


True Der Variablenkern greift direkt auf die Data-Callback- 

Schnittstelle der OPC-Spezifikation 1.0 zu. 

False Der Variablenkern greift auf die Data-Callback- 

Schnittstelle der OPC-Spezifikation 2.0 zu. Scheitert 

der Verbindungsaufbau über diese Schnittstelle, so 

wird die Verbindung über die OPC-spezifizierte 

Schnittstelle 1.0 hergestellt. 

Die Verwendung des Parameters "nur Data-Callback-Interface V1.0 

benutzen" ist sinnvoll, wenn bekannt ist, dass der OPC-Server der 

1.0 Spezifikation entspricht oder der Verbindungsaufbau explizit 

auf dieser Spezifikation beruhen soll.


5.33 OPC-Server hat Unicode-Strings 

Parameter der Definitionen der Prozessanbindung / OPC-Server hat Unicode-Strings / Beispiel Variablenadapter 103 













Der Parameter "OPC-Server hat Unicode-Strings" bewirkt, dass 

Strukturelemente vom Datentyp VT_BSTR, die innerhalb eines 

Byteblocks übertragen werden, als Unicode-Strings interpretiert 

und auf den internen Prozessvariablencache übertragen werden. 

Unicode-Strings unterscheiden sich im Wesentlichen durch den 

Zeichenaufbau von ASCII-Strings. Während in einem ASCII-String 

ein Zeichen durch ein Byte repräsentiert wird, werden im Unicode- 

String zwei Bytes pro Zeichen verwendet. In einem 

Strukturelement vom Datentyp VT_BSTR wird die Länge des 

Strings durch den Parameter "Feldgröße" angegeben. Die Angabe 

"OPC-Server hat Unicode-Strings" bestimmt also die Größe des 

gesamten Byteblocks maßgeblich, wenn ein Strukturelement den 

Datentyp VT_BSTR einnimmt. 


True Vor dem Lesen aus der SPS wird geprüft, ob ein 

Strukturelement den Datentyp VT_BSTR einnimmt. 

Dabei wird die Blockgröße automatisch angepasst. Erst 

dann wird der Datenblock angefordert. Nach Erhalt des 

Blocks wird der interne Prozessvariablencache gemäß 

dem Aufbau der Struktur mit den Bytes des 

empfangenen Blocks gefüllt. Da der Variablenkern 

intern mit Unicode-String arbeitet, ist bei der 

Übertagung von BSTR-Daten keine weitere Anpassung 

nötig. 



Prozessvariablencache zusammengestellt. 

Anschließend wird der Block zur SPS übertragen.


Parameter der Definitionen der Prozessanbindung / OPC-Shutdown-Interface nicht verbinden / Beispiel Variablenadapter 104 





empfangenen Blocks gefüllt. Dabei werden die 

empfangenen ASCII-Strings in Unicode-Strings 

gewandelt. 




werden die im internen Prozessvariablencache 

gehaltenen Unicode-Strings zu ASCII-Strings 

konvertiert. Danach wird dieser Block direkt zur SPS 

übertragen. 

Die Wandlung "ASCII"↔"Unicode" erfolgt mithilfe der 

ACP (Ansii-Cdepage). 

Die Verwendung des Parameters "OPC-Server hat Unicode-Strings" 

ist abhängig von der verwendeten SPS. Sie ist nur sinnvoll, wenn 

der Parameter "Strukturzugriff" auf "als Bytestream" eingestellt ist 

und Strukturen als Datentypen für Prozessvariablen verwendet 

werden. 





→Parameter "Bytetausch" 


unterstützt. 

5.34 OPC-Shutdown-Interface nicht verbinden 


Beschreibung Der Parameter "OPC-Shutdown-Interface nicht verbinden" 

bestimmt das Verhalten des Variablenkern beim Beenden der OPC- 

Server-Applikation. Wird der OPC-Server beendet, während der als 

Client angeschlossene Variablenkern läuft, kann dies dem 

Variablenkern über das Shutdown-Interface gemeldet werden. 


True Die Meldung über das Shutdown-Interface des OPC- 

Servers wird ignoriert. Ein Fehler wird generiert. 

False Die Meldung über das Shutdown-Interface des OPC- 

Servers wird aufgenommen. Der Variablenkern 

versucht anschließend, die Verbindung neu 

aufzubauen.


5.35 OPC-Servername 


Parameter der Definitionen der Prozessanbindung / OPC-Servername / Beispiel Variablenadapter 105 

Beschreibung Der OPC-Servername gibt den systemweiten eindeutigen Namen 

(ProgID) der Kommunikationskomponente aus der Windows- 

Registrierung an. 

Über die Schaltfläche wird der Dialog zur Auswahl eines OPC- 

Servers geöffnet. 

Der Dialog zur Auswahl eines OPC-Servers hat folgende 

Bedienelemente: 

Element Beschreibung 

Beschreibung Beschreibung des OPC-Servers 

OPC-Server ProgID des OPC Servers 

OK Beendet den Dialog und übernimmt die 

getroffenen Einstellungen. 

Abbrechen Beendet den Dialog und verwirft die getroffenen 

Einstellung.


5.36 Ordnungsnummer 

Parameter für Strukturelement 

Parameter der Definitionen der Prozessanbindung / Ordnungsnummer / Beispiel Variablenadapter 106 

Beschreibung Gibt die Position des Strukturelementes innerhalb der Struktur an. 

Je nach Einstellung des Parameters "Ordnungsnummer als 

Byteoffset" in der Strukturdefinition hat die Angabe 

Ordnungsnummer folgende Bedeutung: 

Einstellung Ordnungsnummer als 

Byteoffset 

5.37 Ordnungsnummer als Byteoffset 

Parameter für Struktur 

Beschreibung 

Wahr Die Ordnungsnummer wird als 

Byteoffset zur Prozessvariablenadresse 

hinzugezählt, um auf das 

Strukturelement zuzugreifen. 

Falsch Die Ordnungsnummer gibt die 

Reihenfolge der Strukturelemente an. 

Der Byteoffset auf das Strukturelement 

errechnet sich aus der Länge aller 

Strukturelemente, deren 

Ordnungsnummer kleiner ist. 

Beschreibung Gibt an, wie der Parameter "Ordnungsnummer" in den 

Strukturelementen dieser Struktur interpretiert wird. 


Wahr Die Ordnungsnummer eines 

Strukturelementes wird als Byteoffset 

zur Prozessvariablenadresse 

hinzugezählt, um auf das 

Strukturelement zuzugreifen. 

Falsch Die Ordnungsnummer gibt die 

Reihenfolge der Strukturelemente an. 

Der Byteoffset auf das Strukturelement 

errechnet sich aus der Länge aller 

Strukturelemente, deren 

Ordnungsnummer kleiner ist.


5.38 Rechnername 


Parameter der Definitionen der Prozessanbindung / Rechnername / Beispiel Variablenadapter 107 

Beschreibung Gibt den Netzwerknamen des Rechners an, auf dem die 

Kommunikationskomponente installiert ist. Üblicherweise wird der 

Rechnername über den OPC-Server-Auswahldialog bestimmt 

(siehe Parameter OPC-Servername). Wird kein Rechnername 

angegeben, so geht das System davon aus, dass die 

Kommunikationskomponente lokal installiert ist. Der Name des 

lokalen Rechners kann explizit angegeben werden. Es ist jedoch zu 

unterscheiden, dass in diesem Fall der Zugriff auf die 

Kommunikationskomponente über DCOM erfolgt (nicht über COM). 

5.39 Schreibzugriffe 


Für die "Standard"-Laufzeit 

Als Rechnername kann entweder direkt der Name eines Computers 

oder ein Verweis auf den Namen eines Computers angegeben 

werden. Die Angabe eines Verweises wird dem Variablenkern 

durch ein führendes "@"-Zeichen im Rechnernamen bekannt 

gegeben. 

In der Projektkonfiguration ist eine Sektion namens 

"Rechnernamen" enthalten. Hier werden die als Rechnernamen 

angegebene Synonyme aufgelöst. 

Beschreibung Bestimmt, ob der schreibende Zugriff auf Prozessvariablen dieser 

Gruppe in der Kommunikationskomponente synchron oder 

asynchron erfolgen soll. 


synchron Der Variablenkern reicht eine Schreibanforderung 

an die Kommunikationskomponente weiter und 

wartet, bis der Schreibauftrag ausgeführt wurde. 

Das synchrone Schreiben erhöht die 

Datenkonsistenz in der SPS, da die 

Kommunikationskomponente diesen synchronen 

Schreibauftrag direkt ausführt. 

asynchron Der Variablenkern schickt eine Anforderung zum 

Schreiben eines Prozessvariablenwertes an die 

Kommunikationskomponente. Hier wird die 

Schreibanforderung gepuffert und nach der 

Bearbeitung aller vorhergehenden asynchronen 

Schreibanforderungen ausgeführt. 

Für Prozessvariablen aus VisiWin-Treibern hat diese Einstellung 

nur eine Funktion, wenn der Parameter "Synchrone 

Kommunikation ermöglichen" aktiviert ist. Ansonsten werden die 

Variablenanforderungen asynchron ausgeführt.


5.40 Separatorzeichen 

Parameter der Definitionen der Prozessanbindung / Separatorzeichen / Beispiel Variablenadapter 108 


(VisiWin Treiber), Interne Variablen 

Beschreibung Bestimmt das Trennzeichen für die hierarchische Ansicht im 

Variableneditor. Zur Laufzeit hat dieser Parameter keine Funktion. 

In der Editoransicht wird das Separatorzeichen dazu verwendet, 

die Prozessvariablen hierarchisch in Namensräumen zu gliedern. 

D.h. gleiche Teile von Prozessvariablennamen, die durch das 

Separatorzeichen getrennt werden, werden als Zugriffsknoten im 

Projektexplorer dargestellt. 


Standardwert "."


5.41 Sicherheit 

Parameter für Kommunikationskanal (OPC-UA-Server) 

Parameter der Definitionen der Prozessanbindung / Sicherheit / Beispiel Variablenadapter 109 

Beschreibung Die Karteikarte "Sicherheit" stellt Einstellungen zur Verfügung, die 

die Sicherheit der Verbindung und der Kommunikation zum OPC- 

UA-Server parametrieren. 

Die verwendeten Sicherheitseinstellungen werden während der 

Initialisierungsphase der Verbindung zwischen Client 

(Visualisierung) und OPC-UA-Server ausgehandelt. Ob ein 

Zertifikataustausch und eine Verschlüsselung zwischen Client und 

Server vereinbart werden, hängt davon ab, welche Verfahren 

Client und Server zulassen und in welcher Reihenfolge der 

Vergleich zwischen den Verfahren ausgeführt wird. 

Auf dem "Sicherheit"-Dialog wird in den Bereichen "Erlaubte 

Sicherheitsstufen" und "Erlaubte Verschlüsselungen" festgelegt, 

welche Verfahren der Client zulässt. Ein hier deaktivierter 

Listeneintrag wird vom Client nicht zugelassen. Die Reihenfolge 

der Listeneinträge sind spaltenweise von oben nach unten als 

Rangfolge zu interpretieren. 

In der Auswahlliste "Sicherheits- und Verschlüsselungsoptionen" 

wird die Reihenfolge festgelegt, in der Client und Server die 

Zulässigkeit eines Verfahrens aushandeln. Das erste Verfahren, bei 

dem Client und Server zustimmen, wird dann verwendet. 

Folgende Einstellungen sind hier erlaubt: 

Niedrigste zugelassene 

Sicherheitsstufe verwenden 

Die Listen "Erlaubte 

Sicherheitsstufen" und "Erlaubte 

Verschlüsselungen" werden bei 

der Verbindungsherstellung in 

der oben angegebenen 

Reihenfolge zum Aushanden der 

Verfahren durchlaufen. Das 

erste Verfahren, dem die beiden 

Seiten zustimmen, wird 

verwendet.


5.42 Standardsprache 

Parameter der Definitionen der Prozessanbindung / Standardsprache / Beispiel Variablenadapter 110 

Höchste zugelassene 

Sicherheitsstufe verwenden 

Die Listen werden bei der 

Verbindungsherstellung in 

umgekehrter Reihenfolge zum 

Aushanden der Verfahren 

durchlaufen. 

Wird keine Übereinstimmung von zulässigen Verfahren ermittelt, 

kann die Verbindung nicht hergestellt werden. Dies wird in der 

Log-Datei des Systems als Fehler gemeldet. 

Dateiname Serverzertifikat 

Die Identifizierung zwischen OPC-UA-Server und Client beinhaltet 

den Austausch eines Zertifikats. Beim ersten Verbindungsaufbau 

wird bei entsprechender Verfahrenseinstellung "identifizieren" oder 

"identifizieren und verschlüsseln" ein Zertifikat vom Server 

angefordert. Bei Erhalt des Zertifikates fragt das System, ob es als 

vertrauenswürdig eingestuft werden soll.Bei entsprechender 

Bestätitigung wird das erhaltene Zertifikat unter dem im Feld 

"Dateiname Serverzertifikat" Namen im Unterordner "Cert" des 

Projektverzeichnisses abgespeichert. Ab diesem Zeitpunkt wird das 

gespeicherte Zertifikat zum Identifizieren des OPC-UA-Servers 

verwendet. 

Der Client generiert selbst ebenfalls ein Zertifikat, das 

gegebenenfalls beim Server als autentisch eingetragen werden 

muss. 

Fehler beim Vergleichen des Zertifikates werden in der Log-Datei 

des Systems vermerkt. 

Parameter für Einheitenklasse (sprachabhängig) 

Beschreibung Über den Parameter "Standardsprache" kann festgelegt werden, 

welche Einheit in einer Einheitenklasse verwendet weren soll, 

wenn zur Laufzeit eine Sprache eingestellt wird, für die keine 

Einheit projektiert wurde. 

Beispiel: 

Die Einheit Meter/Inch soll zur Laufzeit sprachabhängig 

(Projektsprachen Deutsch/ Englisch (USA)/ Französisch/ Italienisch) 

umgeschaltet werden. In der entsprechenden Einheitenklasse 

werden zwei Einheiten projektiert 

1. Deutsch (Umschaltkennung: 1031) 

2. Englisch (Umschaltkennung: 1033) 

Die Standardsprache wird auf 1031 eingestellt. Damit wird bei 

einer Sprachumschaltung zur Laufzeit in die Sprachen 

Französisch/Italienisch automatisch die für die deutsche Sprache 

projektierte Einheitenumrechnung benutzt.


Parameter der Definitionen der Prozessanbindung / Startwerte nicht synchron einlesen / Beispiel Variablenadapter 111 

5.43 Startwerte nicht synchron einlesen 

Parameter für Kommunikationskanal (OPC-Server), Kommunikationskanal (OPC- 

UA-Server), Kommunikationskanal (VisiWin-Treiber), 

Kommunikationskanal (VisiWinNET-Treiber) 

Beschreibung Der Parameter "Startwerte nicht synchron einlesen" bestimmt das 

Initialisierungsverhalten bei der ersten Datananforderung. Der 

Variablenkern liest im Normalfall bei der ersten Anforderung eines 

Prozessvariablenwertes den Wert synchron aus der 

Kommunikationsschnittstelle. Damit werden Fehlzugriffe und 

fehlerhafte Datendarstellungen in der Applikation vermieden. In 

bestimmten Fällen kann dies jedoch zum Fehlerfall, bzw. zu 

unerwünschten Verzögerungen führen. 


True Bei der erstmaligen Anforderung eines 

Prozessvariablenwertes wird ein Lesezugriff gestartet. 

Ist dieser Lesezugriff asynchron (gemäß dem Parameter 

"Lesezugriffe" der Definition "Gruppe"), so ist der 

interne Prozessvariablencache des Variablenserver 

solange nicht initialisiert, bis die asynchrone Antwort 

vom OPC-Server zurückkommt. Erst dann kann der 

Wert an die Visualisierung weitergereicht werden. 

Bevor die ersten Werte aus der 

Kommunikationskomponente zurückkommen, werden 

in diesem Fall z.B. in den Steuerelementen falsche "0"- 

Werte angezeigt.


Parameter der Definitionen der Prozessanbindung / Startwerte nicht synchron einlesen / Beispiel Variablenadapter 112 

False Bei der erstmaligen Anforderung eines 

Prozessvariablenwertes wird ein synchroner Lesezugriff 

gestartet, d.h. der Variablenkernel wartet im 

Leseaufruf auf die Funktionsausführung der 

Kommunikationskomponente. Diese behandelt den 

synchronen Aufruf üblicherweise höher priorisiert 

(direkt nach der aktuell laufenden Anfrage), also eher. 

Der zurückgegebene Wert wird vom Variablenkernel 

direkt nach Erhalt an den Visualiserungsclient 

zurückgegeben. 

In bestimmten Fällen tritt durch das erstmalige 

synchrone Lesen ein Fehler auf. Dieser zeichnet sich 

dadurch aus, dass direkt nach dem Start des Projektes 

die Meldung "Item Read Error ():- 0x1" im 

VisiWinNET Manager erscheint. Die Begründung für 

diese Phänomen ist in der noch nicht vollständigen 

internen Initialisierung des OPC-Servers zu suchen. 

Weitere Schwierigkeiten, die das erstmalige synchrone 

Lesen erzeugen können, sind die relativ langen 

Ladezeiten von Formularen, die eine größere Anzahl 

von Prozessvariablendarstellungen beinhalten und der 

daraus resultierende scheinbar vollständige Stillstand 

der Applikation bis hinunter zum Variablenkernel 

(Nicht nur die Visualisierungsoberfläche steht still, 

auch andere, zeitkritische Vorgänge können nicht mehr 

durchgeführt werden). 

Für VisiWin-Treiber hat diese Einstellung nur eine Funktion, wenn 

der Parameter "Synchrone Kommunikation ermöglichen" aktiviert 

ist. Ansonsten werden die ersten Variablenanforderungen 

asynchron ausgeführt. 


unterstützt.


5.44 Steuerobjekt 


Parameter der Definitionen der Prozessanbindung / Steuerobjekt / Beispiel Variablenadapter 113 

Beschreibung Der Parameter "Steuerobjekt" legt fest, welches Objekt/ welche 

Objekte den Datentransfer zwischen Variablenkern und 

Kommunikationskomponente steuern. In Abhängigkeit vom 

eingestellten "Aktivierungsmodus" unterscheiden sich die 

möglichen Eingaben: 

Beschreibung 

Aktivierungsmodus "mit 

Steuervariable" 

Akivierungsmodus Steuerobjekt 

automatisch Das Steuerobjekt wird ignoriert. Der 

Datentransfer wird automatisch auf 

Clientanforderung gesteuert (Siehe auch 

Parameter "Aktivierungsmodus"). 

mit 

Steuervariable 

Applikationsgesteuert 

Der Wert einer Variablen wird dazu 

verwendet, den Datentransfer zu steuern 

(Beschreibung siehe unten). 

Der Datentransfer wird über 

Methodenaufrufe aus den 

Visualisierungsapplikationen gesteuert 

(Beschreibung siehe unten). 

immer Das Steuerobjekt wird ignoriert. Der 

Datentransfer wird automatisch nach der 

Initialisierung des Variablenkerns gestartet 

(Siehe auch Parameter "Aktivierungsmodus"). 

Durch die Steuervariable lassen sich verschiedene manuelle 

Datentransferfunktionen auslösen. Der in der 

Visualisierungsapplikation veränderte Wert der Steuervariablen 

wird vom Variablenkern interpretiert und damit der 

Datenaustausch zwischen Kommunikationskomponente und 

Variablenkern gesteuert. 

Die einzelnen Steuerfunktionen sind bitkodiert. 

Bitnummer Beschreibung 

0 Gruppe deaktivieren. Diese Funktion erlaubt z.B. im 

Fehlerfall, die Gruppe zu deaktivieren, ohne den 

Zustand der Bits 3 und 4 zu ändern. 

1 Das Setzen des Bits löst ein einmaliges Lesen der 

Prozessvariablen dieser Gruppe aus. Nach dem 

Lesevorgang wird das Bit automatisch zurückgesetzt. 

2 Das Setzen des Bits löst ein einmaliges Schreiben der 

Prozessvariablen dieser Gruppe aus. Nach dem 

Schreibvorgang wird das Bit automatisch 

zurückgesetzt. 

3 Das Setzen des Bits führt dazu, dass die 

Prozessvariablen dieser Gruppe im durch den 

Parameter "Abtastzeit" spezifizierten Zyklus gelesen 

werden. 

4 Das Setzen des Bits führt dazu, dass Schreibaufträge 

auf Prozessvariablen dieser Gruppe erlaubt sind.


Beschreibung 

Aktivierungsmodus 

"Applikationsgesteuert" 

Parameter der Definitionen der Prozessanbindung / Steuerobjekt / Beispiel Variablenadapter 114 

Der Datenaustausch wird durch den Aufruf der Methoden 

"AddActiveForm" und "ReleaseActiveForm" (Namensraum 

"VisiWinNET.Services, Klasse "AppService") gesteuert. Diese 

Funktionen erwarten als Parameter einen Namen, der mit der im 

Steuerobjekt angegebenen Zeichenfolge verglichen wird. Im 

Steuerobjekt kann als Zeichenfolge ein oder mehrere 

Aktivierungsbezeichner angegeben werden. Dabei ist zu beachten: 

• Einzelne Namen werden durch Semikolonzeichen (;) getrennt. 

• Die Verwendung vom "*"-Platzhaltern zur Festlegung mehrerer 

Namen ist erlaubt. (Z.B. die Angabe "Form*" enthält alle mit 

"Form" beginnenden Aktivierungsbezeichner). 

Der Aufruf der Methode "AddRunningForm" startet den 

Datentransfer einer Gruppe. 

Der Aufruf "RemoveRunningForm" stoppt den Datentransfer einer 

Gruppe. 

Intern werden die Aufrufe "AddRunningForm" und 

"RemoveRunningForm" gezählt, d.h. zu jedem "AddRunningForm"- 

Aufruf muss es ein "RemoveRunningForm" geben, damit die 

Kommunikation gestoppt wird.


5.45 Strukturzugriff 


Parameter der Definitionen der Prozessanbindung / Strukturzugriff / Beispiel Variablenadapter 115 

Beschreibung Bestimmt, wie auf Prozessvariablen vom Datentyp einer 

Strukturdefinition zugegriffen wird. 


als Bytestream Wird eine Prozessvariable vom Datentyp einer 

Struktur gelesen/beschrieben, so werden die 

Daten als Bytestream zwischen OPC-Server 

und Variablenkern ausgetauscht. VWOPC- 

Server benutzen dieses Datenformat. 

als Struktur 

(IEC1131) 

als 

Einzelvariablen 

Wird eine Prozessvariable vom Datentyp einer 

Struktur gelesen/beschrieben, so werden die 

Daten als Variantdaten zwischen OPC-Server 

und Variablenkern ausgetauscht. 

Während der Initialisierungsphase wird beim 

OPC-Server jedes Strukturelement als einzelne 

Prozessvariable angemeldet. Der blockweise 

Zugriff auf eine Prozessvariable vom Datentyp 

einer Strukturdefinition ist also ein Zugriff auf 

jedes Strukturelement in dieser 

Prozessvariablen. 

Die Einstellung des Strukturzugriff-Parameters ist abhängig vom 

funktionalen Umfang des OPC-Servers. Grundsätzlich gilt: 

VWOPC-Server benutzen den Modus "als Bytestream". 

OPC-Server, die keine erweiterten Datentypen kennen, müssen auf 

den Modus "als Einzelvariablen" eingestellt werden, wenn im 

VisiWinNET-Projekt Strukturdefinitionen verwendet werden. 

Weitere Informationen befinden sich üblicherweise in der 

Dokumentation des OPC-Servers. 


unterstützt.


Parameter der Definitionen der Prozessanbindung / Synchrone Kommunikation ermöglichen / Beispiel Variablenadapter 116 

5.46 Synchrone Kommunikation ermöglichen 

Parameter für Kommunikationskanal (VisiWin-Treiber) 

Beschreibung Der Parameter "Synchrone Kommunikation ermöglichen" stellt ein, 

ob der Variablenkern synchrone Aufrufe bei einem VisiWin-Treiber 

verwendet. Dies ist insbesondere dann von Bedeutung, wenn: 

• Der lesende oder schreibende Zugriff in einer Gruppe auf 

"synchron" eingestellt ist (→Parameter 

"Lesezugriffe"/"Schreibzugriffe") 

• Der Parameter "Startwerte nicht synchron einlesen" der 

Kommunikationskomponente auf "False" eingestellt ist. 


True Synchrone Aufrufe werden verwendet. 

False Synchrone Aufrufe werden als asynchrone Aufrufe 

ausgeführt. Dies ist das Verhalten, das VisiWinNET 

standardmäßig vor der Version 4.07 zeigte. 


unterstützt.


5.47 Text 


Parameter der Definitionen der Prozessanbindung / Text / Beispiel Variablenadapter 117 

Beschreibung Legt eine sprachumschaltbaren Text zur Variablen fest. Dieser 

Text wird in folgenden Steuerelementen angezeigt, wenn dort die 

Eigenschaft 'UseItemText' auf 'true' eingestellt ist: 

• Bar 

• CheckBox 

• ExtendedSlider 

• Key 

• Label 

• RadioButton 

• Switch 

• Text 

• Variable 

• VarIn 

• VarOut 

Wird ein VarIn mithilfe einer 'TouchKeyboard'-Komponente über 

eine Bildschirmtastatur bedient und ist die Eigenschaft 

'UseItemText' auf 'true' gestellt, wird der Variablentext als 

Titelzeile in der Bildschirmtastatur angezeigt. 

Das programmatische Lesen des Textes in der aktuellen Sprache 

ist bei Objekten der folgenden Typen über die Eigenschaft 'Text' 

möglich: 

• VisiWinNET.DataAccess.Item 

• VisiWinNET.DataAccess.StateItem 

• VisiWinNET.DataAccess.AnalogItem 

• VisiWinNET.DataAccess.DigitalItem 

• VisiWinNET.DataAccess.ItemInfo 

Der Variableneditor zeigt den Text nur in der im Projekt gewählten 

Entwicklersprache an. Die Übersetzung kann im Texteditor unter 

dem Knoten "Variablen" erfolgen. 

Der Text wird erst im Texteditor angezeigt, nachdem im 

Variableneditor in der Entwicklersprache ein Text angegeben 

wurde.


5.48 Treibername 

Parameter für Kommunikationskanal (VisiWin-Treiber) 

Parameter der Definitionen der Prozessanbindung / Treibername / Beispiel Variablenadapter 118 

Beschreibung Der Treibername gibt den systemweiten eindeutigen Namen der 

Kommunikationskomponente aus der Windows-Registrierung an. 

Über die Schaltfläche wird der Dialog zur Auswahl eines 

VisiWin-Treibers geöffnet. 

Der Dialog zur Auswahl eines VisiWin-Treibers hat folgende 

Bedienelemente: 

Element Beschreibung 

OK Übernimmt den ausgewählten VisiWin-Treiber 

und beendet den Dialog. 

Abbrechen Beendet den Dialog ohne die Parameter zu 

übernehmen. 

Hilfe Öffnet dieses Dokument.


5.49 Umschaltvariable 

Parameter der Definitionen der Prozessanbindung / Umschaltvariable / Beispiel Variablenadapter 119 

Parameter für Einheitenklasse (variablenabhängig), Multiplexer 

Beschreibung Einheitenklasse 

(variablenabhängig) 

Bestimmt die Variable, deren Wert zum Umschalten zwischen den 

Einheitendefinitionen einer Einheitenklasse benutzt wird. 

Zur Laufzeit wird dieser Prozessvariablenwert mit den Werten der 

Parameter "Umschaltkennung" aller Einheiten der betreffenden 

Einheitenklasse verglichen. Bei Übereinstimmung des Wertes wird 

die entsprechende Einheitenformel (Parameter "x1", "x2", "y1", 

"y2") zum Umrechnen aller Prozessvariablen genutzt, die sich auf 

diese Einheitenklasse beziehen. Erreicht die Umschaltvariable 

einen Wert, für den es in der Einheitenklasse keine 

Umschaltkennung gibt, so wird der Wert der Prozessvariablen, die 

sich auf diese Einheitenklasse beziehen, ohne Umrechnung 

übernommen. 

Beschreibung Multiplexer Bestimmt die Variable, deren Wert den Multiplexer umschaltet. 

Multiplexer beinhalten eine Zuordnungstabelle, deren Spalten 

durch das Anlegen von Umschaltzuständen projektiert werden. Im 

Spaltenkopf steht dabei der Wert, der von der Umschaltvariablen 

angenommen werden muss, um die entsprechenden Variablen in 

den Spaltenfeldern auf die durch die Alias-Spalte benannte 

Variable umzulenken. 

5.50 Umschaltkennung 


Beschreibung Je nach Einheitenklassentyp (variablen-/sprachabhängig) 

beinhaltet die Umschaltkennung einen Wert, der bestimmt, wann 

die Einheitenumrechnung in dieser Einheitenklasse aktiv ist. 

Einheitenklassentyp Beschreibung 

(sprachabhängig) Dieser Einheitenklassentyp bewirkt die 

Umrechnung von Prozessvariablenwerten 

in Abhängigkeit von der in einer 

Applikation gewählten Sprache. In den 

Parameter Umschaltkennung muss die 

entsprechende Kennung (LCID, für 

Deutsch (Deutschland) z.B. 1031) 

eingegeben werden. Nähere Informationen 

über die Umschaltkennungen für die 

einzelnen Sprachen befinden sich in der 

Beschreibung des Indextextsystems. 

(variablenabhängig) Eine Einheitenklasse dieses Typs bewirkt 

die Umrechung über Einheitenobjekte in 

Abhängigkeit von einem 

Prozessvariablenwert (siehe Parameter 

"Umschaltvariable"). Hier ist also der Wert 

anzugeben, den die Umschaltvariable 

annehmen muss, damit die 

Einheitenumrechnung in dieser 

Einheitenklasse aktiv ist.


5.51 Umschaltzustände 

5.52 URL 

Parameter für Multiplexer, Variablenadapter 

Parameter der Definitionen der Prozessanbindung / Umschaltzustände / Beispiel Variablenadapter 120 

Beschreibung Multiplexer und Variablenadapter beinhalten im Tabelleneditor 

eine Zuordnungstabelle, deren Spalten durch das Anlegen von 

Umschaltzuständen projektiert werden. 

Der Name eines Umschaltzustandes findet sich im Kopf der 

entsprechenden Spalte wieder. 

Multiplexer interpretieren den Namen als Wert der 

Umschaltvariablen, der angenommen werden muss, um die 

entsprechenden Variablen in den Spaltenfeldern auf die durch die 

Alias-Spalte benannte Variable umzulenken. 

Variablenadapter werden zur Entwicklungszeit auf einen 

Umschaltzustand konfiguriert. Im Projektexplorer ist über den 

Knoten "Variablen→Variablenadapter→Konfiguration" für jeden 

projektierten Variablenadapter ein "aktiver Umschaltzustand" 

festzulegen. 


Beschreibung Legt den Verbindungsendpunkt des OPC-UA-Servers fest. In der 

URL sind folgende Angaben enthalten. 

::/[:] 

Protokollpräfix Folgende Angaben sind zulässig: 

"opc.tcp" für das binäre Protokoll. 

"opc.http" oder "opc.https" für Webservices 

Rechner Entweder der Rechnername oder die IP- 

Adresse des Zielsystems oder beim Zugriff 

auf das lokale System die Angabe "localhost". 

Port Optionale Angabe des Ports, auf dem der 

OPC-UA-Server lauscht. Der Defaultwert 

hängt vom Protokollpräfix ab: 

"4840" (tcp) 

"80" (http) 

"443" (https) 

Beispiele opc.http::/192.168.4.2 

Verbindung zum OPC UA Server auf dem Rechner mit der IP 

192.168.4.2 über Webservices und den Standardport 80 

opc.tcp::/localhost:4841 

Verbindung zum OPC UA Server auf dem lokalen System über das 

Binärprotokoll und den Port "4841"


5.53 Variablenoptionen 


Parameter der Definitionen der Prozessanbindung / Variablenoptionen / Beispiel Variablenadapter 121 

Beschreibung Der Parameter "Variablenoptionen" enthält bitcodierte 

Einstellmöglichkeiten zu einer Prozessvariablen. 

Parametername Bit Beschreibung 

Im VWOPC-Kernel 

nicht als 

öffentliches Item 

zur Verfügung 

stellen 

Wertänderungen 

im Protokollserver 

aufzeichnen 

Elementauflösung 

zugunsten 

Powertagzählung 

unterdrücken 

0 Der Variablenkern kann selbst als OPC-Server angesprochen 

werden. Wird diese Einstellung in den Variablenoptionen 

gesetzt, so wird die Prozessvariable für externe 

Clientanwendungen, die den Variablenkern als OPC-Server 

nutzen, nicht zur Verfügung gestellt. 

Diese Option wird von Strukturelementen nicht unterstützt. 

1 Bei Nutzung des Protokollservers wird eine Wertänderung in 

dieser Prozessvariablen aufgezeichnet. 

2 Eine Prozessvariable, die nur als komplette Struktur oder Feld 

in der Applikation benötigt wird, kann mit dieser Einstellung 

belegt werden. Dies hat zur Folge, dass die gesamte 

Prozessvariable als nur ein Powertag in die Zählung der 

Lizenzierungsüberprüfung eingeht. Allerdings wird damit 

auch die Auflösung der Prozessvariablen in ihre Elemente 

zwischen VWE-Kernel und Applikation nicht mehr unterstützt. 

Die Anbindung von Steuerelementen an die Elemente der 

Prozessvariablen z.B. ist dann nicht mehr möglich. 

Clientintern 3 Ist die Option aktiv, puffert der Variablenclient die 

Prozessvariable ohne Hilfe des Variablenkernes. In einem 

Client-Server-System wird die Prozessvariable also nicht im 

Variablenkern für alle Clients gemeinsam gehalten. Die 

Prozessvariable kann dadurch in jeder Client-Applikation 

einen individuellen Wert einnehmen. 

Diese Option kann nur für interne Variablen eingestellt 

werden. 

Diese Option wird von Strukturelementen nicht unterstützt.


Parameter der Definitionen der Prozessanbindung / Variablenoptionen / Beispiel Variablenadapter 122 

Hinweise für "Elementauflösung zugunsten 

Powertagzählung unterdrücken": 

typische Anwendungen für diese Option sind: 

• Variablenfelder z.B. für den 'XYGraph' 

• Felder und Strukturen, die nicht in der Anzeige benötigt 

werden, die aber über VWGet/VWSet aufgerufen werden. 

Ist die Option aktiv, können folgende Funktionen auf die Elemente 

der Variablen nicht mehr ausgeführt werden: 

• Verknüpfung mit Anzeigeelementen in den 'VWItem'- 

Eigenschaften 

• Verknüpfung mit Definitionsfunktionen (z.B. Verwendung der 

Elemente als Ereignisvariablen von Alarmen) 

• Lesen/Schreiben der einzelnen Elemente über VWGet/VWSet 

Die vom System gezählten Variablen werden im Dialog 

"Laufzeitlizenzierung" angezeigt. Dieser Dialog wird über das 

Kontextmenü des obersten Knoten im 

VisiWinNET-Projektexplorer geöffnet. 

Hinweise für "Clientintern": 

Diese Option wird üblicherweise für Steuervariablen im Client- 

Server-System verwendet. 

Beispiel: In einem Client-Server-Projekt wird über eine Variable 

die Umschaltung einer Einheitenumrechnung gesteuert. Dabei soll 

die Umschaltung der Einheit jedoch individuell für eine 

Clientanwendung erfolgen. Damit die Variable nicht die 

Einheitenumrechnung aller beteiligten Client-Anwendungen 

umschaltet, wird die Steuervariable als Clientintern markiert.


5.54 Variablen statisch aktivieren 

Parameter der Definitionen der Prozessanbindung / Variablen statisch aktivieren / Beispiel Variablenadapter 123 


Beschreibung Der Parameter "Variablen statisch aktivieren" bestimmt das 

Aktivierungsverhalten von Prozessvariablen im OPC-Server. 


True Der Variablenkern meldet die Prozessvariablen 

entsprechend der projektierten Gruppen beim OPC- 

Server an und aktiviert sie. Es werden also ohne 

weitere Clientanforderung Daten zwischen 

Variablenkern und OPC-Server ausgetauscht. 

False Der Variablenkern meldet die Prozessvariablen 

entsprechend der projektierten Gruppen beim OPC- 

Server an. Erst auf Anforderung eines Clients (z.B. 

beim Laden eines Formulars) werden die 

entsprechenden Prozessvariablen aktiviert. Ab diesem 

Zeitpunkt werden die Prozessvariablenwerte mit dem 

OPC-Server ausgetauscht. 

Dieser Parameter kann in Abhängigkeit vom gewählten OPC- 

Server das Verhalten der Visualisierungsapplikation wesentlich 

beeinflussen. Üblicherweise ist das Aktivieren einer 

Prozessvariablen ein zeitlich unkritischer Faktor im System. Der 

Austausch von Daten sollte allgemein minimiert werden. Es gibt 

jedoch Ausnahmen, bei denen aufgrund der internen Architektur 

des OPC-Servers genau das Gegenteil zu beobachten ist: Während 

der Datenaustausch zwischen Variablenkern und OPC-Server kaum 

Rechenleistung in Anspruch nimmt, werden durch das Aktivieren 

von Prozessvariablen die Systemresourcen drastisch reduziert. In 

diesem Fall sollte der Parameter "Variablen statisch aktivieren" 

gewählt werden.


Parameter der Definitionen der Prozessanbindung / Variablenwerte bei OPC Quality BAD nicht übernehmen / Beispiel Variablenadapter 124 

5.55 Variablenwerte bei OPC Quality BAD nicht übernehmen 

Parameter für Kommunikationskanal (OPC-Server), Kommunikationskanal (OPC- 

UA-Server) 

Beschreibung Legt fest, welcher Wert in den Variablenkern geschrieben wird, 




false Der vom OPC-Server übertragene Wert wird in 

die Variable eingetragen. 

5.56 Variablen beim Deaktivieren weiterlesen 

true • Ist kein Ersatzwert angegeben, und zeigt das 

Quality-Flag nicht "LastKnown" an, behält 

die Prozessvariable im Variablenkern ihren 

alten Wert. 


• Zeigt das Quality-Flag "LastKnown" an und 

ist kein Ersatzwert angegeben, wird der vom 

OPC-Server übertragenen Wert in die 

Variable eingetragen. 

• Wurde jedoch ein Ersatzwert angegeben und 

wurde im Eratzwertmodus die Option "Bei 

Kommunikationsabbruch senden" aktiviert, 

wird der Ersatzwert in die Variable 

eingetragen. 

In allen drei Fällen wird das Quality-Flag 

entsprechend übernommen und über den Client 

ein Change-Ereignis ausgelöst. 

Beschreibung Legt fest, das Variablen, die nicht mehr von der Applikation 

benötigt und deshalb im Variablenkern abgemeldet werden, 

trotzdem aus der Kommunikationskomponente weiter angefordert 

werden. 

Einige Kommunikationskomponenten bauen ihren internen 

Datencache jeweils neu auf, sobald Variablen abgemeldet werden. 

Nimmt dieser Vorgang eine längere Zeit in Anspruch, treten unter 

Umständen zeitliche Verzögerungen und Übertragungstimeouts 

auf. 

Der Entwickler kann über die Einstellung "Variablen beim 

Deaktivieren weiterlesen" das Abmelden von Variablen in der 

Kommunikationskomponente unterdrücken, so dass diese 

zeitlichen Verzögerungen nicht mehr auftreten.


Parameter der Definitionen der Prozessanbindung / Verbindungsversuche nach Initialisierungsphase wiederholen / Beispiel Variablenadapter 125 

5.57 Verbindungsversuche nach Initialisierungsphase wiederholen 

5.58 Version 


Beschreibung Gelingt die Verbindungsherstellung zum OPC-Server (z.B. 

aufgrund einer erhöhten Auslastung von Netzwerk oder OPC- 

Server) während der Initialisierungsphase nicht, versucht der 

Variablenkern auch danach weiter zyklisch, den Kontakt zum OPC- 

Server herzustellen. 


Beschreibung Bestimmt die Versionsnummer der registrierten 

Kommunikationskomponente. OPC-Server können unter gleichem 

Namen in verschiedenen Versionen auf einem Rechner installiert 

werden. Ist dies der Fall, kann über die Versionsnummer der 

gewünschte OPC-Server ausgesucht werden.


5.59 VWE erzeugt Items (CallR-Server) 

Parameter der Definitionen der Prozessanbindung / VWE erzeugt Items (CallR-Server) / Beispiel Variablenadapter 126 


Beschreibung Bestimmt die CallR-Fähigkeit des OPC-Servers. Grundsätzlich ist 

im Umgang mit OPC-Servern folgende Kategorisierung zu 

beachten: Während der Initialisierung liest der OPC-Server seine 

Prozessvariablendefinitionen (ItemID, Adresse in der SPS, 

Datentyp,...) aus einer für ihn spezifischen Quelle (Projektdatei). 

Ein Client, der Prozessvariablen mit dem OPC-Server austauschen 

will, muss dies über die Übergabe der ItemID anmelden. Diese 

Spezifikation wird von allen OPC-Servern erfüllt. 

CallR-Server ermöglichen zusätzlich die dynamische Erzeugung 

von Prozessvariablendefinitionen im OPC-Server, d.h.: Ein Client 

kann dem OPC-Server eine Prozessvariablendefinition zur Laufzeit 

übermitteln. Der OPC-Server speichert die neue 

Prozessvariablendefinition. Auf Anfrage vom Client wird der 

Datenaustausch zwischen OPC-Server und SPS gestartet. 

VisiWinNET unterstützt die beiden Kategorien in folgender Form: 

OPC-Server mit einer eigenen Projektdatei können über die 

Browse-Funktion im Editor ausgelesen werden. Dabei werden die 

in der Applikation benötigten Prozessvariablendefinitionen aus 

dem OPC-Server-Projekt in die VisiWinNET- Projektdatenbank 

gespiegelt. Auf Anforderung aus einer Applikation sendet der 

Variablenkern die ItemID zum OPC-Server und meldet den 

Datentransfer an. 

Zusätzlich können Prozessvariablendefinitionen im Editor selbst 

erzeugt werden. Diese werden dann zur Laufzeit zum OPC-Server 

gesendet. 


aktiv Die Kommunikationskomponente wird als CallR-Server 

behandelt. Während der Initialisierung werden alle 

Prozessvariablendefinitionen aus der VisiWinNET- 

Projektdatenbank an den OPC-Server gesendet. 

inaktiv Die ItemID-Werte der Prozessvariablendefinitionen 

werden als Kennung an die 

Kommunikationskomponente übersendet, wenn ein 

Datenaustausch von einer Clientapplikation 

angefordert wird.


5.60 Worttausch VT_I4, VT_UI4 

Parameter der Definitionen der Prozessanbindung / Worttausch VT_I4, VT_UI4 / Beispiel Variablenadapter 127 













Der Parameter "Worttausch VT_I4, VT_UI4" bewirkt, dass die zwei 

Worte (ein Wort = 2 Bytes) eines Strukturelementes vom Datentyp 

VT_I4 bzw. VT_UI4 innerhalb eines übertragenen Byteblockes 

miteinander getauscht werden. 







Strukturelement dabei vom Datentyp VT_I4 /VT_UI4, 

so werden die beiden Worte miteinander getauscht. 





den Datentyp VT_I4/VT_UI4 einnimmt. Ist dies der 

Fall, so werden die beiden Worte des Wertes 

miteinander getauscht. Anschließend wird der Block 

zur SPS übertragen. 











Parameter der Definitionen der Prozessanbindung / Worttausch VT_I4, VT_UI4 / Beispiel Variablenadapter 128 

Die Verwendung des Parameters "Worttausch VT_I4, VT_UI4" ist 

abhängig von der verwendeten SPS. Sie ist nur sinnvoll, wenn der 

Parameter "Strukturzugriff" auf "als Bytestream" eingestellt ist und 

Strukturen als Datentypen für Prozessvariablen verwendet werden. 







unterstützt.


5.61 Worttausch VT_R4, VT_R8 

Parameter der Definitionen der Prozessanbindung / Worttausch VT_R4, VT_R8 / Beispiel Variablenadapter 129 













Der Parameter "Worttausch VT_R4, VT_R8" bewirkt, dass zwei 

aufeinanderfolgende Worte (Wort = 2 Bytes) eines 

Strukturelementes vom Datentyp VT_R4 bzw. VT_R8 innerhalb 

eines übertragenen Byteblockes miteinander getauscht werden. 







Strukturelement dabei vom Datentyp VT_R4 /VT_R8, 

so werden zwei aufeinander folgende Worte 

miteinander getauscht. 





den Datentyp VT_R4/VT_R8 einnimmt. Ist dies der Fall, 

so werden die jeweils aufeinanderfolgenden Worte des 

Wertes miteinander getauscht. Anschließend wird der 

Block zur SPS übertragen. 











Parameter der Definitionen der Prozessanbindung / Worttausch VT_R4, VT_R8 / Beispiel Variablenadapter 130 

Die Verwendung des Parameters "Worttausch VT_R4, VT_R8" ist 

abhängig von der verwendeten SPS. Sie ist nur sinnvoll, wenn der 

Parameter "Strukturzugriff" auf "als Bytestream" eingestellt ist und 

Strukturen als Datentypen für Prozessvariablen verwendet werden. 







unterstützt.


5.62 x1 


Parameter der Definitionen der Prozessanbindung / x1 / Beispiel Variablenadapter 131 

Beschreibung Legt den ersten Prozessvariablen-Rohwert fest, der zur 

Bestimmung der Einheitenumrechnung erforderlich ist. Die 

Einheitenumrechnung erfolgt über die Definition von zwei 

Punkten. Durch diese Punkte lässt sich eine Geradengleichung 

erstellen. 

Steigung m= (x2-x1)/(y2-y1) 

Offset b = y2- m∗ x2 

Allgemein gilt y= m∗x+b 

Die Umrechnung beim Lesen eines Wertes erfolgt über die 

obenstehende Gleichung Umrechnungswert = m∗Rohwert+b. 

Die Angaben "Rohwert" und "Umrechnungswert" beziehen sich auf 

die Verwendung der Einheitenklasse: 

• Wird eine Einheitenklasse im Parameter "Einheitenklasse 

(Prozess)" einer Prozessvariablen verwendet, ist der Rohwert 

der Prozessvariablenwert aus der 

Kommunikationskomponente. Der Umrechnungswert ist der 

Wert im Variablenkern. 

• Wird eine Einheitenklasse im Parameter "Einheitenklasse 

(Anzeige)" einer Prozessvariablen verwendet, ist der 

Umrechnungswert der in den Steuerelementen angezeigte 

Wert. Der Rohwert ist der im Variablenkern gepufferte 

Prozessvariablenwert. 

Beim schreibenden Zugriff (bei der Verwendung als 

Einheitenklassen (Prozess) aus dem Variablenkern in die 

Kommunikationskomponente, bei einer Einheitenklasse (Anzeige) 

vom Steuerelement in den Variablenkern) wird die Umrechnung 

umgekehrt ausgeführt: 

Rohwert = (Umrechnungswert -b)/ m


5.63 x2 

5.64 y1 

5.65 y2 


Parameter der Definitionen der Prozessanbindung / x2 / Beispiel Variablenadapter 132 

Beschreibung Legt den zweiten Prozessvariablen-Rohwert fest, der zur 




erstellen. Weitere Informationen finden sich in der Beschreibung 

des Parameters "x1". 


Beschreibung Legt den ersten Prozessvariablen-Umrechnungswert fest, der zur 







Beschreibung Legt den zweiten Prozessvariablen-Umrechnungswert fest, der zur 






5.66 Zeitzonendifferenz 


Beschreibung Bestimmt die Differenz der Zeitzone. OPC-Server sind vollständig 

netzwerkfähig, d.h. sie können unter Umständen bei einer 

verteilten Applikation auch in einer anderen Zeitzone 

angeschlossen sein. Beim Anmelden einer Gruppe wird vom 

Variablenkern die Zeitzonendifferenz an den OPC-Server 

übergeben. Bei der Anforderung von Prozessvariablenwerten 

dieser Gruppe wird vom OPC-Server eine Zusatzinformation über 

die Zeit der Abtastung des Prozessvariablenwertes (TimeStamp) 

übergeben. Dabei wird der Zeitstempel um den im Parameter 

"Zeitzonendifferenz" angegebenen Wert korrigiert. 

Datentyp Long 

Standardwert 0


5.67 zu deaktivierende Kanäle 

Parameter für Variablenadapter 

Parameter der Definitionen der Prozessanbindung / zu deaktivierende Kanäle / Beispiel Variablenadapter 133 

Beschreibung Legt fest, welche Kommunikationskanäle deaktiviert werden, wenn 

der entsprechende Umschaltzustand aktiviert ist. 

Die VisiWinNET-Eigenschaftenseite zeigt für Variablenadapter auf 

der Karteikarte "Erweitert" zwei Listen an. 

In der "Umschaltzustände"-Liste werden vom Projekteur Einträge 

generiert, die entsprechende Konfigurationseinträge beschreiben. 

Die "zu deaktivierende Kanäle"-Liste beinhaltet für jeden 

Umschaltzustand die Möglichkeit zum Deaktivieren von einzelnen 

Kommunikationskanälen. 

Das Deaktivieren von Kanälen unterdrückt Fehlermeldungen beim 

Projektstart. Stehen für das Projekt beispielsweise zwei alternative 

Steuerungen zur Verfügung, ermöglichen Variablenadapter die 

Umschaltung zwischen den beiden Steuerungen ohne Änderungen 

in den Anbindungen an Variablennamen. Da auf dem Zielsystem 

aber immer nur eine Steuerung angeschlossen ist, muss der 

Kommunikationskanal für die nicht vorhandene Steuerung 

deaktiviert werden. Ansonsten versucht der Variablenkern beim 

Start des Systems auch die nicht vorhandene Steuerung 

anzusprechen und generiert gegebenenfalls eine Fehlermeldung. 

5.68 Zugriffsart 


Beschreibung Legt fest, ob auf eine Prozessvariable lesend/schreibend 

zugegriffen werden kann. 

Einstellung DB- 

Wert 

Beschreibung 

R 1 Der Variablenkern liest Prozessvariablenwerte 

aus der Kommunikationskomponente. Ein 

schreibender Zugriff ist nicht erlaubt. 

W 2 Der Variablenkern schreibt 

Prozessvariablenwerte in die 

Kommunikationskomponente. Ein lesender 

Zugriff ist nicht möglich. 

R/W 3 Sowohl lesender als auch schreibender Zugriff 

ist erlaubt. 

1 x R/ W 4 Während der Initialisierungsphase des 

Variablenkerns wird der Prozessvariablenwert 

einmal eingelesen, danach ist nur noch ein 

schreibender Zugriff möglich.


5.69 Zugriffspfad 


Parameter der Definitionen der Prozessanbindung / Zugriffspfad / Beispiel Variablenadapter 134 

Beschreibung Der Parameter "Zugriffspfad" ist eine OPC-Server-spezifische 

Einstellmöglichkeit zur Festlegung des Datenweges zwischen OPC- 

Server und SPS. Der Variablenkern reicht den Parameterwert nur 

zum OPC-Server durch. Weitere Informationen über die 

Einstellmöglichkeiten sind in der entsprechenden Dokumentation 

nachzulesen.


6 Variablen anbinden 

Variablen anbinden / Zugriffspfad / VWEngine-Fenster 135 

Nach der Projektierung der Variablendefinitionen unterstützt VisiWinNET verschiedene 

Wege zur Betrachtung oder Manipulation von Variablenwerten. 

Die gebräuchlichste Art ist dabei die Anbindung von Steuerelementen und 

visualisierungsspezifischen Funktionen an Variablen über den Variablenauswahldialog. 

Dieser Dialog unterstützt den Projekteur bei der Auswahl einer Prozessvariablen, deren 

Wert entweder im Steuerelement angezeigt werden oder eine spezielle Funktion erfüllen 

soll. 

Zu Diagnosezwecken können Variablen aber auch über das "VWEngine"-Fenster 

betrachtet werden. Zusätzlich zu den in der Projektdatenbank definierten Variablen 

werden hier auch alle Systemvariablen aufgeführt. 

Für den rein programmatische Zugriff auf Variablen enthält VisiWinNET Funktionen, die 

dem Programmierer das Lesen, Setzen oder Überwachen von Variablenwerten erlauben. 

6.1.1 VWEngine-Fenster 

Die VisiWinNET-Engine, also der Variablenkern wird im Rahmen des VWNManagers 

gestartet. Üblicherweise erfolgt der Start über das Visualisierungsprojekt. Immer wenn 

das Projekt gestartet wurde, wird neben der Systemuhrzeit in der Windows-Taskleiste 

ein -Symbol eingeblendet. Über den Eintrag VWEngine im Kontextmenü des Symbols 

öffnet sich ein Dialog, der alle Variablen des Projektes zur Auswahl anbietet. Über die 

Funktionen des Dialoges ist sowohl die Betrachtung als auch die Manipulation einzelner 

Prozesswerte möglich (Siehe Handbuch VWNManager). 

Unter anderem werden hier auch alle Systemvariablen gezeigt. 

6.1.2 Variablenauswahldialog 

Der Variablenauswahldialog listet die Definitionen auf, die im Projekt als Datenquelle eines 

Steuerelementes oder einer Definition zur Verfügung stehen: 

Prozessvariablen Interne und externe Variablen, die als Definitionen in der 

Projektdatenbank vorliegen. 

Unter dem Knoten "Intern" wird ein Teil der zur Verfügung 

stehenden Systemvariablen aufgeführt. 

Variablen, die als Feld oder als Strukturdatentyp definiert sind, 

beinhalten in der Dialogansicht die Elemente als Unterknoten. 

Diese Unterknoten stehen jedoch nicht zur Verfügung, wenn in der 

Variablen die Option "Elementauflösung zugunsten 

Powertagzählung unterdrücken" aktiviert wurde. 

Variablensätze von 

Multiplexern und 

Variablenadaptern 

Die hier aufgeführten Datenquellen ergeben sich aus der 

Projektierung der Definitionstypen "Multiplexer" und 

"Variablenadapter". Hier werden die Bezeichner aufgeführt, die als 

Alias in den entsprechenden Variablensätzen angegeben wurden.


Variablen anbinden / Zugriffspfad / Variablenauswahldialog 136 

Pseudovariablen Pseudovariablen haben kein Speicherabbild. Sie zeichnen sich 

jedoch durch einen Datentyp aus. Verwendet werden 

Pseudovariablen immer dann, wenn die Funktion eines 

Steuerelementes verwendet werden soll, ohne das eine 

entsprechende Prozessvariable zur Anbindung vorliegt. 

VisiWinNET-Steuerelemente sind nur bedienbar, wenn eine 

Variable über die VWItem-Eigenschaft angebunden wird. 

So kann z.B. das Bildschirmtatstatur-optimierte CheckBox- 

Steuerelement von VisiWinNET dazu verwendet werden, eine 

Einstellung vorzunehmen, die nur die Visualisierungsoberfläche 

betrifft und im Variablenkern kein entsprechendes Abbild hat. Der 

Wert der angebundenen Pseudovariablen ist nur im Steuerelement 

lesbar. Über eine entsprechende Programmierung kann der Wert 

im Steuerelement ausgewertet oder gespeichert werden. 

Üblicherweise werden Pseudovariablen in VisiWinNET SMART 

nicht verwendet, weil eine sinnvolle Auswertung des 

Pseudovariablenwertes ohne Programmierung nicht funktioniert. 

Für den SMART.-Steuerelementeentwickler kann die Anbindung 

an Pseudovariablen jedoch sinnvoll sein. 

Systemvariablen Systemvariablen ordnen einem festen Variablenbezeichner eine 

vorgegebene Funktion zu. Für einige Systemvariablen müssen in 

der Projektdatenbank entsprechende Definitionen angelegt sein. 

Andere bedürfen dieser Definition nicht. 

Mehr dazu im Kapitel "Systemvariablen" 

Hinweise: 

• Der Inhalt des Variablenauswahldialoges wird meist durch die aufrufende Komponente 

gefiltert. So werden z.B. Variablen vom Typ "VT_BSTR" in der VWItem-Eigenschaft eines 

"Key"-Steuerelementes nicht aufgelistet, respektive nicht unterstützt. Der Dialog 

beinhaltet zusätzlich die Möglichkeit zur benutzerdefinierten Filterung von Datentypen 

und Zugriffsrechten. Sollte also eine Variable auf dem Dialog nicht sichtbar sein, ist 

zuerst zu prüfen, ob eine Anbindung an den Datentyp überhaupt möglich ist. 

Anschließend muss geprüft werden, ob ein benutzerdefinierter Filter die Variable aus 

der Ansicht ausschließt. 

• Die Auswahl einer Variablen beruht immer auf dem vollständigen Variablenbezeichner 

(Ggf. .). Wird eine Variable unter dem Knoten "Extern" 

ausgewählt, deren vollständiger Bezeichner in den Knoten "Multiplexer" oder 

"Variablenadapter" noch einmal auftaucht ist dies gleichwertig mit der entsprechende 

Auswahl unter den genannten Knoten. Das Laufzeitsystem behandelt die Anbindung an 

Variablensätze aus Multiplexern und Variablenadaptern vorrangig.


Variablen anbinden / Zugriffspfad / Systemvariablen 137 

Am oberen Rand des Variablenauswahldialoges befindet sich eine Werkzeugleiste mit 

folgenden Bedienelementen 

• Eingabefeld "VWItem" zum Suchen eines Variablenbezeichners: Während der Eingabe 

eines Variablenbezeichners selektiert die Suchfunktion den ersten möglichen Treffer in 

der Variablenansicht 

• Schaltfläche zum Weitersuchen: Durch einen Klick auf die Schaltfläche springt die 

Selektion in der Variablenansicht auf den nächsten Suchtreffer 

• Schaltfläche zum Umschalten zur hierarchischen Ansicht (Aufteilung der 

Prozessvariablen in Namensräume) 

• Schaltfläche zum Umschalten zur flachen Ansicht (Alphabetisch sortierte Tabelle 

aller Variablen ) 

6.1.3 Systemvariablen 

VisiWinNET beinhaltet folgende Systemvariablen, die nur zur Verfügung stehen, wenn die 

entsprechenden internen Prozessvariablen in der Projektdatenbank definiert sind: 

Systemvariablenbezeichner Funktion 

__CURRENT_USER. 

NAME 


FULLNAME 


GROUPNAME 


GROUPTEXT 


LEVEL 


SECONDS_TO_AUTOLOGOFF 

Gibt den Anmeldenamen des aktuell angemeldeten 

Benutzers wieder 

Gibt den vollen Namen des aktuell angemeldeten 


Gibt den Benutzergruppennamen des aktuell 

angemeldeten Benutzers wieder 

Gibt den sprachumschaltbaren Benutzergruppennamen 

des aktuell angemeldeten Benutzers wieder 

Gibt die Autorisierungsebene des aktuell angemeldeten 


Gibt die Anzahl der Sekunden bis zum automatischen 

Abmelden wieder 

Diese Variablen müssen definiert sein, damit sie ihre Funktion erfüllen. Sie fließen jedoch 

damit auch in die Variablenzählung der Lizenzierung ein. Der Entwickler kann die Variablen 

löschen, wenn ersie nicht benötigt.


Variablen anbinden / Zugriffspfad / Funktionen 138 

Zusätzlich beinhaltet VisiWinNET folgende Systemvariablen, die ohne die entsprechenden 

Definitionen im Variablenkern angelegt werden. 

Systemvariablenbezeichner Funktion 

__ACKNOWLEDGE_RESET Setzt den Quittierungsstatus aller aktuell anstehenden 

Alarme auf "Nicht quittiert" 

__ACTIVE_ALARMS Gibt die Anzahl der anstehenden Alarme zurück 

__ACTIVE_ITEMS Gibt die Anzahl aller aktiven Variablen zurück 

__CHANNEL__STATE : eindeutige numerische Kennung des 

Kommunikationskanals. 

Gibt bitverschlüsselte Informationen zum 

Kommunikationsstatus an. 

__CYCLE_MAX Gibt die maximale Zykluszeit des Variablenkerns seit dem 

Start an 

__CYCLE_TIME Gibt die aktuelle Zykluszeit des Variablenkerns an. 

__MASTER_SERVER z. Zt. nicht implementiert 

__SYSTEM_STATE Gibt den Systemstatus zurück 

Diese Variablen fließen nicht in die Variablenzählung der Lizenzierung ein. Jedoch ist zu 

beachten, dass gleichnamig definierte Variablen vermieden werden sollten. 

6.1.4 Funktionen 

Die folgende Beschreibung beinhaltet Beispiele für VisiWinNET 

Professional. In VisiWinNET SMART können die Beispiele 

aufgrund der fehlenden Programmierumgebung nicht 

ausgeführt werden. 

Der programmatische Zugriff auf Prozesswerte hängt von der Konstellation des Projektes ab: 

Prozessvariablenwert eines Steuerelementes lesen/setzen zu einem beliebigen 

Zeitpunkt 

Das Lesen eines Prozessvariablenwertes, der in einem Steuerelement angebunden ist, 

erfolgt über die 'Value'-Eigenschaft des in der VWItem-Eigenschaft angebundenen Objektes. 

Beispiel VarIn: 

int val = (int)varIn3.VWItem.Value; 

Prozessvariablenwert eines Steuerelementes lesen/setzen bei 

Variablenwertänderung 

Im 'Change'-Ereignis wird eine Variablenwertänderung gemeldet. Das Argument 'e' 

beinhaltet den geänderten neuen Wert in der 'Value'-Eigenschaft. 

private void varIn3_Change(object sender, VisiWinNET.DataAccess.ChangeEventArgs e) 

{ 

int val = (int) e.Value; 

} 

Prozesvariablenwert überwachen ohne Steuerelement 

Die Komponente 'ItemServer' meldet eine Variablenwertänderung im 'Change'-Ereignis. Die 

Komponente hat jedoch keine grafische Darstellung.


Prozessvariablenwerte lesen/setzen zu einem beliebigen Zeitpunkt ohne 

Steuerelement 

Variablen anbinden / Zugriffspfad / Funktionen 139 

Die Funktion VWSet schreibt einen Prozessvariablenwert unter Angabe des entsprechenden 

Variablenbezeichners direkt in den Variablenkern und damit zur SPS. 

int val = 42; 

VisiWinNET.Services.AppService.VWSet("Ch1.Simulation.Dummy.Sinus.Funktion_1.Value", 

val); 

Das Lesen erfolgt mit 'VWGet' 

int valRead = (int) 

VisiWinNET.Services.AppService.VWGet("Ch1.Simulation.Dummy.Sinus.Funktion_1.Value"); 

Prozessvariablen dynamisch ohne Unterstützung durch Formulare überwachen 

Im Namensraum VisiWinNET.DataAccess liegen verschiedene Typen zur Überwachung von 

Variablen. Diese Typen (von 'ItemBase' erbend) beinhalten eine 'Name'-Eigenschaft zur 

Kennzeichnung der zu überwachenden Variablen und ein Change-Ereignis. Die Kapselung 

mehrerer solcher Objete kann folgendermaßen aussehen: 

public class DynamicVarWatch : IDisposable 

{ 

System.Collections.ArrayList DataAccessItems; 

public DynamicVarWatch(string[] variables) 

{ 

DataAccessItems = new System.Collections.ArrayList(); 

foreach (string var in variables) 

{ 

VisiWinNET.DataAccess.Item DataAccessItem = new 

VisiWinNET.DataAccess.Item(); 

DataAccessItem.Change += new 

VisiWinNET.DataAccess.ChangeHandler(DataAccessItem_Change); 

DataAccessItem.Name = var; 

DataAccessItems.Add(DataAccessItem); 

DataAccessItem.Attach(); 

} 

} 

public void DataAccessItem_Change(object sender, 

VisiWinNET.DataAccess.ChangeEventArgs e) 

{ 

VisiWinNET.DataAccess.Item DataAccessItem = 

(VisiWinNET.DataAccess.Item)sender; 

System.Diagnostics.Debug.WriteLine(DataAccessItem.Name + " " + 

e.Value.ToString()); 

} 

public void Dispose() 

{ 

foreach (VisiWinNET.DataAccess.Item DataAccessItem in DataAccessItems) 

{ 

DataAccessItem.Change -= new 

VisiWinNET.DataAccess.ChangeHandler(DataAccessItem_Change); 

DataAccessItem.Detach(); 

DataAccessItem.Dispose(); 

} 

} 

}


6.2 Initialverhalten beim Formularwechsel 

Variablen anbinden / Initialverhalten beim Formularwechsel / Funktionen 140 

Das folgende Kapitel fasst das Verhalten des Variablenaustausches beim Laden eines 

Formulares zusammen. VisiWin berücksichtigt dabei durch zwei unterschiedliche 

Mechanismen die Anforderungen, dass einerseits direkt beim Start aktuelle Daten in den 

Steuerelementen angezeigt werden, andererseits aber auch die Zeit zum Laden eines 

Formulars möglichst gering gehalten wird. 

Grundsätzlich optimiert der Variablenkern die Kommunikation zur SPS, indem nur Variablen 

ausgetauscht werden, die benötigt werden, durch folgende An-/Abmeldemechanismen: 

• Die während des geamten Applikationslaufes benötigt Variablen werden beim Start der 

Applikation angemeldet. Typisches Beispiel hierfür sind Variablen, die vom Alarm- oder 

Archivserver benötigt werden. 

• Über die Gruppensteuerung können Variablen gruppenweise aus der Applikation heraus 

an- oder abgemeldet werden. Diese Aufgabe obliegt dem Projekteur. Er kann hier gezielt 

das Verhalten des Systems umgehen, indem er durch Setzen von Steuervariablen die 

Kommunikation einzelner Gruppen ein- oder ausschaltet. 

• Variablen, die in einer Gruppe liegen, die nicht gesteuert wird (Akivierungsmodus = 

automatisch), werden nur bei Bedarf, d.h. auf Clientanforderung gelesen oder 

geschrieben. Dabei ist zu beachten, dass diese Variablen im Normalfall für die 

Erstanforderung einmal synchron gelesen werden. Diese synchrone Leseanforderung ist 

nötig, um beim Laden eines Formulars die Steuerelemente möglichst zügig mit Daten zu 

versorgen. Das synchrone Lesen kann über den Parameter "Startwerte nicht synchron 

einlesen" abgeschaltet werden. Dann aber muss damit gerechnet werden, dass direkt 

nach dem Öffnen des Formulars in den Steuerelementen kein aktueller Wert angezeigt 

wird. 

Der An-/Abmeldevorgang beeinflusst unter Umständen temporär die Geschwindigkeit der 

Kommunikationskomponente. Beinhaltet der Treiber oder OPC-Server eine Blockung, d.h. 

versucht er intern, durch blockweises Lesen oder Schreiben die 

Kommunikationsgeschwindigkeit zu erhöhen, wird bei jeder An-/Abmeldung einer Variablen 

jeweils eine Neuberechnung der Blockgrößen erforderlich. 

Der VisiWin Variablenkern kann dieses Problem umgehen, indem er die Variablen quasi in 

einem Sammelaufruf an- oder abmeldet, so dass eine Neuberechnung der Blöcke in der 

Kommunikationskomponente für die Anmeldung mehrerer Variablen gemeinsam erfolgt. 

Anforderungen an die Applikation für diesen Mechanismus sind: 

• In der Projektkonfiguration muss im Knoten "Projektkonfiguration→Client" (unter 

Compact "Projektkonfiguration→Laufzeit") auf der Karteikarte "Kompatibilität" die Option 

"Optimierte Aktivierung von Variablen beim Formularwechsel" aktiv sein. 

• Ein Formular, dass den blockweisen An-/Abmeldevorgang unterstützen soll, muss von 

"VisiWinNET.Forms.BaseForm" erben.



Der Ladevorgang eines Formulars verläuft mit diesen Einstellungen in fünf Schritten: 

• Zuerst meldet das Formular den blockweisen Anmeldevorgang beim Variablenkern an 

• Anschließend melden sich die Steuerelemente mit den angeforderten 

Variablenbezeichnern beim Variablenkern 

• Durchläuft das Formular die EndInit-Funktion (also nachdem alle Steuerelemente 

geladen wurden), zeigt es dem Variablenkern an, dass alle Variablen sich angemeldet 

haben. 

• Jetzt meldet der Variablenkern die Variablen bei den Kommunikationskomponenten über 

einen Aufruf an 

• Wird der Aufruf beim Variablenkern synchron ausgeführt, bleibt das Formular in der 

"EndInit"-Funktion so lange stehen, bis der Variablenkern mit dem Anmelden der 

Variablen fertig ist. Erst dann wird das Formular angezeigt.



Beachten Sie, dass ein erstes "Change"-Ereignis mit "Source = ChangedByConfig" von einem 

Steuerelement ausgelöst wird, wenn es geladen wurde, also bevor der Variablenkern die 

Gelegenheit hatte, die Variablen anzumelden. Hier werden keine realen Daten aus dem 

Prozess übergeben. 

Als Projekteur haben Sie so die Auswahl zwischen drei Lademechanismen für Formulare: 

Mechanismus Bedingung Vorteile Nachteile 

Asynchroner 

Abruf der 

Variablenwerte 

synchroner 

Abruf der 

Variablenwerte 

synchroner 

Abruf der 

Variablenwerte/ 

blockweise 

Aktivierung der 

Variablen 

"Startwerte nicht 

synchron einlesen" im 

Kommunikations- 

kanal aktiviert 




deaktiviert. 

Kompatibilitäts-Flag 

"Optimierte 

Aktivierung von 


Formularwechsel" 

deaktiviert oder 

VisiWin-Basisformular 

nicht verwendet 




deaktiviert 

Kompatibilitäts-Flag 

"Optimierte 

Aktivierung von 


Formularwechsel" 

gesetzt 

VisiWin-Basisformular 

verwendet 

Formular muss nicht 

auf die ersten Daten 

warten→Schnelle 

Anzeige 

sichere 

Datenkonsistenz 

Daten werden richtig 

in den 

Steuerelementen 

angezeigt. 

Die Anmeldung der 

Variablen erfolgt 

performant 

Unter Umständen kurze 

Zeit falsche Daten in den 

Steuerelementen 

sichtbar 

Ggf. langsame 

Formularwechsel 

Vor der Anzeige können 

in den "Change"- 

Ereignissen der 

Steuerelemente falsche 

Werte übergeben 

werden.

Inhalt - INOSOFT GmbH

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?