Funktion und Eigenschaften

Zwischen NC (NC-Kanal, NC-channel), Oberfläche (GUI) und SPS (PLC) können beliebige Werte über externe Variablen ausgetauscht werden, wobei die Variablen durch die NC transparent behandelt werden, d.h. die Bedeutung der Variablen wird rein durch die Applikation (NC-Programm, Oberfläche und SPS) bestimmt. Die NC hat nur die Aufgabe, diese Variablen zu transportieren und dem Anwender im NC-Programm zur Verfügung zu stellen. Während der Konfigurationsphase wird den externen Variablen ein Name, ein Typ, das Zugriffsrecht (Schreiben und/oder Lesen) und eine Speicherstelle zugewiesen. Die Konfiguration der externen Variablen findet anhand einer ASCII Liste nur einmalig während des Hochlaufs statt.

Neben einfachen Variablen können auch eindimensionale Felder angelegt werden, auf die indiziert zugegriffen wird. Die Variablen können auf einem kanalspezifischen oder auch kanalübergreifenden Speicher angelegt werden. Dabei sind die Werte über die Laufzeit eines NC-Programms hinweg gültig, d.h. werden also z.B. beim Start eines neuen NC-Programms nicht abgelöscht.

Für den Zeitpunkt des Schreibens/Lesens einer Variablen aus dem NC-Programm gibt es zwei Möglichkeiten:

1. Das Schreiben/Lesen einer Variablen wird synchron zur aktuellen NC-Programmbearbeitung durchgeführt, d.h. die zeitliche Sequenz der NC-Befehle und Variablenzugriffe wird sichergestellt.

2. Das Schreiben/Lesen einer Variablen wird zum Zeitpunkt der Decodierung durchgeführt.

Der Zugriff durch die Oberfläche oder die SPS erfolgt nicht synchronisiert zur aktuellen NC-Programmbearbeitung.

Abbildung 1-1: Verwendung externer Variablen


Speichergrösse

TwinCAT CNC: Überblick

Konfiguration und Initialisierung

Speichergröße

Der für die externen Variablen jedes Kanals zur Verfügung stehende Gesamtspeicher ist vor dem Hochlauf der Steuerung festzulegen.

Ø Bei TwinCAT-Systemen erfolgt die Dimensionierung im System-Manager in der HLI Maske (CNCTask-GEO) unter der Rubrik VE.

Ø Bei allen anderen Systemen wird die Größe des VE-Speichers über den Parameter P-STUP-00037 (ext_var_max) in der Hochlaufliste [STUP] festgelegt.

Die hierbei festgelegte Zahl bestimmt die Anzahl an 24-Byte-Blöcken, aus denen der VE-Speicher jedes NC-Kanals besteht. Die globalen Variablen (kanalübergreifend) verwenden einen eigenen Speicherbereich der gleichen Größe. Der reservierte VE-Speicher jedes Kanals und der globale Speicher müssen zwingend größer sein, als der durch das Speicher-Layout (siehe nächstes Kapitel) belegte Speicherbereich.

Reicht der zur Verfügung stehende Speicher für die in der Liste konfigurierten externen Variablen nicht aus, erfolgt die Ausgabe der Fehlermeldung P-ERR-21148. In diesem Fall muß entweder der reservierte Speicher vergrößert werden oder die Größe und Anzahl der konfigurierten externen Variablen muß verringert werden.


Speicher-Layout

Jeder Kanal hat Zugriff auf zwei unterschiedliche Speicherblöcke. Einer davon steht lokal nur für den aktuellen NC-Kanal zur Verfügung, der andere dagegen ist kanal-übergreifend, d.h. kann von allen NC-Kanälen gemeinsam genutzt werden. Die Konfiguration der externen Variablen wird pro NC-Kanal in einer Datei angegeben, in welcher globale und kanalspezifischen Variablen gemeinsam aufgeführt sind.

Abbildung 2-1: Gültigkeitsbereich der Speicher

Mehr:

button Speicherlayout (ab Version V254)

button Speicherlayout (ab Version V2.10.1025.00)


Speicherlayout (ab Version V254)

Über die Konfiguration wird die Sicht des Kanals auf den Speicher und somit dessen logische Strukturierung definiert. Der gesamte Speicher ist als Feld von 24-Byte-Blöcken (Union der Typen aller Inhalte) gerastert. Bei der Definition jeder Variable wird die Startposition durch Angabe des Blockindex in diesem Feld angegeben.

Abbildung 2-2: Speicherlayout resultierend aus gegebener Konfiguration

Eine VE-Variable (auch VE-Array) wird zusammenhängend ab der angegebenen Startposition abgelegt. Ist sie grösser als ein 24-Byte Raster, so wird der folgende Speicherbereich (Raster) mit hinzugezogen. Grundsätzlich ist es auch möglich, mehrere logische Variablen auf die identische Speicherstelle zu legen, d.h. mehrere Sichtweisen auf eine Speicherstelle freizugeben. Eine Überlappungsfreiheit der einzelnen Variablen wird durch die NC nicht überwacht.

Werden einzelne Variablen in den Speicher gelegt, so bleibt je nach Variablengrösse ein nicht genutzter Speicher pro Speicherraster übrig. Dieser ist nicht weiter adressierbar.


Speicherlayout (ab Version V2.10.1025.00)

Ab der CNC-Version V2.10.1025.00 können V.E.Variablen durch Angabe eines Adressoffsets an jede beliebige Stelle des V.E.Variablenspeichers gelegt werden (s. Kapitel 2.4), das 24-Byte Raster entfällt.

Die Angabe eines Adressoffsets ist jedoch nicht zwingend notwendig. Variablen bei denen er nicht angegeben ist, werden im V.E.-Speicher nacheinander lückenlos abgelegt (s. Abbildung 2-3).

Konfigurationslisten nach einer älteren Syntax können auch weiterhin verwendet werden.

Abbildung 2-3: Speicherlayout ab CNC-Version V2.10.1025.00 resultierend aus ge-gebener Konfiguration


Syntax (ab Version V254)

Die Syntax der Konfiguration ab Version V254 wurde so erweitert, dass Elemente mit Defaultwerten vorbelegt sind und Einstellungen über textuelle Konstanten vorgegeben werden können.

Kommentare können ganzzeilig, oder am Ende einer Zeile eingefügt werden.

Bei ganzzeiligem Kommentar muß am Zeilenanfang das Kommentarzeichen "'#", gefolgt von einem Leerzeichen eingefügt werden.

Soll am Ende einer Zeile ein Kommentar eingefügt werden, so muß vor dem Kommentar lediglich ein Leerzeichen vorhanden sein. Wurde in der Zeile jedoch ein String definiert, so muß dem Kommentar das Kommentarzeichen "(" vorangestellt werden.

Leerzeilen sind ebenfalls möglich.

Beispiele für Kommentare:

# ************************************************************************

# Daten

# ************************************************************************

#

# Auflistung

dummy[1] 1 Kommentar

dummy[2] 1 # Kommentar

dummy[3] 1 ( Kommentar

dummy[4] 1 /* Kommentar

...

beispiel[0].bezeichnung STRING_2 (Kommentar, hier Kommentarklammer nötig!)

Beispiel einer ASCII Liste:

# ***************************************

# Externe Variablen V254

# ****************************************

#

anzahl_belegt 2

#

var[0].name GLOBAL_SWR (Globale VE)

var[0].index 0

var[0].type SGN16

var[0].scope GLOBAL

var[0].synchronisation FALSE

var[0].access_rights READ_ONLY

var[0].array_size 0

var[0].size 2 # 2 Byte pro Element

var[0].create_hmi_interface FALSE

#

var[1].name CHANNEL_WR (Kanal VE)

var[1].index 0

var[1].type SGN32

var[1].scope CHANNEL

var[1].synchronisation FALSE

var[1].access_rights READ_ONLY

var[1].array_size 10

var[1].size 4 # 4 Byte pro Element

var[1].create_hmi_interface FALSE

#

Ende

Bezeichner

Wertebereich

Default

Bedeutung

anzahl_belegt

[0; MAX_UNS16]

0

Bei lückenloser Belegung von var[i].* wird hier der Index der zuletzt definierten Variable +1 eingetragen (ilast+1).

Bei lückender Belegung von var[i].* wird hier der höchste Index der definierten Variablen +1 eingetragen (imax+1).

var[i].*

i:= [0; 214]

Datensätze zur Definition der Variablen

name

ASCII-String

Über den Namen wird die Variable identifiziert. Aus diesem wird ein Gesamtname für den NC-Kanal und die Oberfläche zusammengesetzt (z.B. V.E.<name>). Der Name darf dabei nicht länger als 20 Zeichen sein.

Gross- und Kleinbuchstaben werden unterschieden.

index

[0; MAX_SGN32]

-1

Der Index legt die Position im Speicher fest, an welcher die Variable abgelegt wird. Der gesamte Speicher ist dabei als Feld von 24 Byte grossen Einheiten aufgebaut.

Ein Index von 1 zeigt an, dass der Eintrag nicht belegt ist.

type

[BOOLEAN,
SGN08, UNS08, SGN16, UNS16, SGN32; UNS32, REAL64, STRING]

UNS32

Der Typ gibt den Datentyp der Variablen an. Neben elementaren Datentypen (SGN08,...,REAL64) existiert der Datentyp STRING, welcher derzeit inklusiv Endmarke 24 Byte umfasst.

scope

[GLOBAL; CHANNEL]

CHANNEL

Beim Gültigkeitsbereich wird zwischen einem kanalspezifischen und einem kanalübergreifenden, globalen unterschieden.

synchronisation

[TRUE, FALSE]

TRUE

Der Schreib-/Lesezugriff erfolgt normalerweise synchron zur Bearbeitung. In Einzelfällen kann diese implizite Synchronisierung unterdrückt werden (s. Kapitel 3.1.1).

access_rights

[READ_WRITE, READ_ONLY, WRITE_ONLY]

READ_WRITE

Per Default ist ein Schreib-/Lesezugriff auf die Variablen möglich, welcher über den Zugriffsschutz eingeschränkt werden kann.

array_size

[0; MAX_UNS16]

0

Ist die Variable nicht als Feld ausgelegt, so muss die Feldgrösse mit 0 angegeben werden. Ansonsten wird an dieser Stelle die Gesamtgrösse des Feldes festgelegt.

size

[0; MAX_UNS32]

4

Gibt die Grösse der Variablen an inclusiv evtl. Alignmentbytes, d.h. die Differenz zweier nachfolgenden Elemente eines Feldes. Je nach Rechnerarchitektur und Alignmentstrategie kann sich diese Grösse aus den realen Nutzdaten und zusätzlichen Alignmentbytes zusammensetzen.

Größe der Datentypen:

1 BYTE- BOOLEAN,UNS08, SGN08

2-BYTE -SGN16, UNS16

4 BYTE -SGN32, UNS32

8 BYTE- REAL64

24 BYTE -STRING

create_hmi_interface

[TRUE, FALSE]

FALSE

Für jede Variable kann zusätzlich der Zugriff über die Oberfläche durch ein entsprechendes Kommunikationsobjekt ermöglicht werden, falls das Flag gesetzt ist.


Syntax (ab Version V2.10.1025.00)

Ab der CNC-Version V2.10.1025.00 können für die externen Variablen benutzerdefinierte Variablentypen festgelegt werden. Damit lassen sich nun auch im NC-Programm und der PLC komplexe externe Variablenstrukturen verwenden. Voraussetzung dafür ist allerdings, dass in der PLC für Strukturen Byte-Alignment verwendet wird.

Bei der Konfiguration der externen Variablen wird im folgenden zwischen Definition der Variablentypen und der Variableninstanzierung unterschieden.

Mehr:

button Definition von Variablentypen

button Definition der externen Variablen

button Beispiel einer Konfigurationsliste


Definition von Variablentypen

Neben den benutzerdefinierten Variablentypen können auch die elementare Datentypen (BOOLEAN, ..., REAL64) und Zeichenketten vom Typ STRING verwendet werden:

Variablentyp

Größe

BOOLEAN, UNS08, SGN08

1 Byte

UNS16, SGN16

2 Byte

UNS32, SGN32

4 Byte

REAL64

8 Byte

STRING

128 Byte

Ab der CNC-Version V2.10.1025.00 können Stringvariablen inklusive Endekennung bis zu 128 Zeichen umfassen.

Aus Gründen der Abwärtskompatibilität muss für die Verwendung von Stringvariablen mit mehr als 20 Zeichen der Parameter use_extended_string_var = 1 gesetzt werden. In Abhängigkeit des Parameters use_extended_string_var sind Stringvariable auf folgende Zeichenlängen (inklusive Endekennung) begrenzt:

use_extended_string_var = 0: 21 Byte (Default)

use_extended_string_var = 1: 128 Byte

Tabelle 2-1: Größe der Default-Variablentypen

Falls in einer bestehenden Konfiguration nachträglich auf 128-Byte große Stringvariablen gewechselt wird (use_extended_string_var = 1), müssen die Adressen der externen Variablen im Speicher (Index, Byte-Offset) und die PLC angepasst werden, damit nachfolgende Variablen nicht überschrieben werden!

Die Definition der Variablentypen erfolgt in der gleichen Konfigurationsliste wie das Festlegen der externen Variablen.

Im Konfigurationsfile können Kommentare ganzzeilig, oder am Ende einer Zeile eingefügt werden. Bei ganzzeiligem Kommentar muß am Zeilenanfang das Kommentarzeichen "'#", gefolgt von einem Leerzeichen eingefügt werden.

Soll am Ende einer Zeile ein Kommentar eingefügt werden, so muß vor dem Kommentar lediglich ein Leerzeichen vorhanden sein. Wurde in der Zeile jedoch ein String definiert, so muß dem Kommentar das Kommentarzeichen "(" vorangestellt werden.

Leerzeilen sind ebenfalls möglich.

Definition der Variablentypen:

Bezeichner

Wertebereich

Default

Bedeutung

use_extended_string_var

[0; 1]

0

Mit dem Parameter use_extended_string_var kann die zulässige Zeichenanzahl von Stringvariablen von 21 auf 128 Zeichen (jeweils inklusive Endmarke) erhöht werden.

Falls die Adressen der V.E. Variablen in 24-Byte Blöcken (s. 2.2.1 ) vorgegeben sind, ist bei den 128 Byte großen Variablen vom Typ STRING zu beachten, dass sie im Speicherlayout mehrere 24-Byte Blöcke belegen und der Index entsprechend hochgezählt (vergl. Variablenarrays) werden muss.

struct[i] .*

i:= [0; 29]

Datensätze zur Definition der Variablentypen. Das Schlüsselwort struct ersetzt das in älteren CNC-Versionen gebräuchliche Token type. Auf Grund der Abwärtskompatibilität wird jedoch type auch weiterhin unterstützt.

struct[i]. name

ASCII-String

Über den Namen wird der Variablentyp identifiziert. Er darf dabei nicht länger als 20 Zeichen sein. Gross- und Kleinbuchstaben werden unterschieden.

struct[i]. element[j] .*

j:= [0; 49]

Datensätze zu Definition der Elemente des Variablentyps.

struct[i]. element[j].name

ASCII-String

Über den Name wird das Strukturelement identifiziert. Er darf nicht länger als 20 Zeichen sein. Gross- und Kleinbuchstaben werden unterschieden.

struct[i]. element[j].type

ASCII-String

[BOOLEAN,
SGN08, UNS08, SGN16, UNS16, SGN32; UNS32, REAL64, STRING oder benutzerdefiniert]

UNS32

Der Typ gibt den Datentyp des Strukturelements an. Neben elementaren Datentypen (SGN08,...,REAL64) kann hier auch der Datentyp STRING oder ein benutzerdefinierter Datentyp angegeben werden.

struct[i]. element[j].

synchronisation

[TRUE, FALSE]

Wird von Variableninstanzierung geerbt (s. Kapitel 2.4.2 )

Normalerweise erben alle Strukturelemente die Synchronisierungsart für den Schreib-/Lesezugriff (s. Kapitel 3.1.1 ) von der Variableninstanzierung. Mit diesem Parameter kann jedoch die Synchronisationsart für das Strukturelement individuell festgelegt werden.

struct[i]. element[j].

access_rights

[READ_WRITE, READ_ONLY, WRITE_ONLY]

Wird von Variableninstanzierung geerbt (s. Kapitel 2.4.2 )

Normalerweise erben alle Strukturelemente die Zugriffsrechte von der Variableninstanzierung. Mit diesem Parameter kann jedoch das Zugriffsrecht für das Strukturelement individuell festgelegt werden.

struct[i]. element[j].

array_elements

[0; MAX_UNS16]

0

Ist das Strukturelement nicht als Feld ausgelegt, so muss die Feldgrösse mit 0 angegeben werden. Ansonsten wird an dieser Stelle die Anzahl der Feldelemente festgelegt.


Definition der externen Variablen

Bezeichner

Wertebereich

Default

Bedeutung

anzahl_belegt

[0; MAX_UNS16]

0

Bei lückenloser Belegung von var[i].* wird hier der Index der zuletzt definierten Variable +1 eingetragen (ilast+1).

Bei lückender Belegung von var[i].* wird hier der höchste Index der definierten Variablen +1 eingetragen (imax+1).

var[i].*

i:= [0; 214]

Datensätze zur Definition der Variablen

name

ASCII-String

Über den Namen wird die Variable identifiziert. Aus diesem wird ein Gesamtname für den NC-Kanal und die Oberfläche zusammengesetzt (z.B. V.E.<name>). Der Name darf dabei nicht länger als 20 Zeichen sein.

Gross- und Kleinbuchstaben werden unterschieden.

byte_offset

[0; MAX_SGN32]

-1

Der Parameter byte_offset legt die Position im Speicher fest, an welcher die Variable abgelegt wird.

Die Angabe dieses Parameters ist optional. Alle Variablen mit byte_offset = 1 werden im V.E. -Speicher lückenlos hintereinander (beginnend mit Offset 0) angereiht.

type

[BOOLEAN,
SGN08, UNS08, SGN16, UNS16, SGN32; UNS32, REAL64, STRING, benuterzdefiniert]

UNS32

Der Typ gibt den Datentyp der Variablen an. Neben elementaren Datentypen (SGN08,...,REAL64) und dem Datentyp STRING kann hier auch ein benutzerdefinierter Variablentyp (s. Kapitel 2.4.1 ) angegeben werden.

scope

[GLOBAL; CHANNEL]

CHANNEL

Beim Gültigkeitsbereich wird zwischen einem kanalspezifischen und einem kanalübergreifenden, globalen unterschieden.

synchronisation

[TRUE, FALSE]

TRUE

Der Schreib-/Lesezugriff erfolgt normalerweise synchron zur Bearbeitung. In Einzelfällen kann diese implizite Synchronisierung unterdrückt werden (s. Kapitel 3.1.1 ). Falls es sich bei der Variable um eine Variablenstruktur handelt, wird die Synchronisationsart an alle untergeordneten Strukturelemente vererbt. Zusätzlich kann bei der Typdefinition (s. Kapitel 2.4.1 ) die Synchronisationsart für jedes Strukturelement individuell festgelegt werden.

access_rights

[READ_WRITE, READ_ONLY, WRITE_ONLY]

READ_WRITE

Per Default ist ein Schreib-/Lesezugriff auf die Variablen möglich, welcher über den Zugriffsschutz eingeschränkt werden kann. Falls es sich bei der Variable um eine Variablenstruktur handelt, wird das Zugriffsrecht an alle untergeordneten Strukturelemente vererbt. Zusätzlich kann bei der Typdefinition (s. Kapitel 2.4.1 ) das Zugriffsrecht für jedes Strukturelement individuell festgelegt werden.

array_elements

[0; MAX_UNS16]

0

Ist die Variable nicht als Feld ausgelegt, so muss die Feldgrösse mit 0 angegeben werden. Ansonsten wird an dieser Stelle die Anzahl der Feldelemente festgelegt.

size

[0; MAX_UNS32]

Abgeleitet von Datentyp (s. Tabelle 1)

Die Angabe der Variablengröße ist optional. Ist sie nicht angegeben, wird die Größe der Variablen aus ihrem Variablentyp abgeleitet. Die Angabe der Variablengröße ist nur notwendig falls zusätzliche Alignmentbytes berücksichtigt werden müssen. Bei Feldern gibt der Parameter die Größe eines Einzelelements an.

create_hmi_interface

[TRUE, FALSE]

FALSE

Für jede Variable kann zusätzlich der Zugriff über die Oberfläche durch ein entsprechendes Kommunikationsobjekt ermöglicht werden, falls das Flag gesetzt ist. Für Variablen mit benutzerdefiniertem Datentyp hat dieser Parameter keine Auswirkung.


Beispiel einer Konfigurationsliste

Beispiele für Kommentare:

# ************************************************************************

# Daten

# ************************************************************************

#

# Auflistung

dummy[1] 1 Kommentar

dummy[2] 1 # Kommentar

dummy[3] 1 ( Kommentar

dummy[4] 1 /* Kommentar

...

beispiel[0].bezeichnung STRING_2 (Kommentar, hier Kommentarklammer nötig!)

Beispiel für Typdefinition:

use_extended_string_var 1 #Strings mit 128 Zeichen

struct[0].name VECTOR_T

struct[0].element[0].name x

struct[0].element[0].type REAL64

struct[0].element[1].name y

struct[0].element[1].type REAL64

struct[0].element[2].name z

struct[0].element[2].type REAL64

#

struct[1].name TARGET_POINT_T

struct[1].element[0].name point

struct[1].element[0].type VECTOR_T

struct[1].element[1].name valid

struct[1].element[1].type BOOLEAN

struct[1].element[1].access_rights READ_ONLY

struct[1].element[1].synchronisation TRUE

#

struct[2].name TRAJEKTORIE_T

struct[2].element[0].name nbr_points

struct[2].element[0].type SGN32

struct[2].element[1].name name

struct[2].element[1].type STRING

struct[2].element[2].name points

struct[2].element[2].type TARGET_POINT_T

struct[2].element[2].array_elements 10

Beispiele für Variablendefinition:

anzahl_belegt 5

#

var[0].name var_global_1

var[0].type UNS32

var[0].scope GLOBAL

var[0].synchronisation FALSE

var[0].access_rights READ_WRITE

#

var[1].name var_chan_1

var[1].type SGN32

var[1].scope CHANNEL

var[1].synchronisation TRUE

var[1].access_rights READ_WRITE

#

var[2].name array_chan_1

var[2].type SGN16

var[2].scope CHANNEL

var[2].synchronisation TRUE

var[2].access_rights READ_WRITE

var[2].array_elements 20

#

var[3].name name

var[3].type STRING

var[3].scope CHANNEL

var[3].synchronisation TRUE

var[3].access_rights READ_WRITE

#

var[4].name trajektorie

var[4].type TRAJEKTORIE_T

var[4].scope CHANNEL

var[4].synchronisation FALSE

var[4].access_rights READ_WRITE


Einbindung in NC-Hochlauf

Die Konfiguration der externen Variablen wird jedem NC-Kanal getrennt über eine ASCII-Liste bekannt gegeben. Für jeden Kanal wird in der zentralen Hochlaufbeschreibung des Systems ein Dateinamen angegeben, welcher die Konfiguration der externen Variablen diesen Kanals festlegt.

Beispiel: Auszug aus der Hochlaufbeschreibung für zwei Kanäle

# ----------------------------------------

#

# Konfigurierungsdaten Listen

#

# ----------------------------------------

#

listen ASCII

default_sda_mds ..\listen\default_sda.lis

hand_mds ..\listen\hand_mds.lis

rtconf_lis ..\listen\rtconf.lis

#

sda_mds[0] ..\listen\sda_mds1.lis

werkz_data[0] ..\listen\werkz_d1.lis

nullp_data[0] ..\listen\nullp_d1.lis

pzv_data[0] ..\listen\pzv_d1.lis

ve_var[0] ..\listen\ext_var1.lis

hmi[0].objects default

channel[0].objects default

#

sda_mds[1] ..\listen\sda_mds2.lis

werkz_data[1] ..\listen\werkz_d2.lis

nullp_data[1] ..\listen\nullp_d2.lis

pzv_data[1] ..\listen\pzv_d2.lis

ve_var[1] ..\listen\ext_var2.lis

hmi[1].objects default

channel[1].objects default


NC-Programm

Der Zugriff des NC-Kanals auf die externen Variablen erfolgt aufgrund der Schreib-/Leseanweisung auf die Variable V.E.<name> im NC-Programm. Die im NC-Programm zur Verfügung stehenden Variablen setzen sich aus der Vorsilbe V.E. und dem in der Konfigurationsliste der Variablen angegeben Namen <name> zusammen. V.E. Variablen dürfen maximal aus 20 Zeichen bestehen.

Programmierbeispiel
VE-Variablenzugriff in der CNC

N100 $IF V.E.CHANNEL_WR >= 100 (Entspr. dem Wert von V.E.CHANNEL_WR)

(wird in die verschiedenen Fälle)

(verzweigt.)

N110 G01 X100 Y100 F1000

N120 $ELSE

N130 G01 X100 YV.E.CHANNEL_WR F1000 (Geradeninterpolation in)

(Y-Richtung mit dem Wert)
(von CHANNEL_WR)

N140 $ENDIF

N150 V.E.GLOBAL_SWR = V.A.ABS.X (Der externen Variablen wird die)

(absolute X-Koordinate zugewiesen)

N160 G01 XV.E.GLOBAL_SWR (Geradeninterpolation in X-Richtung)

(mit dem Wert von V.E.GLOBAL_SWR)

Programmierbeispiel 2
VE-Variablenzugriff in der CNC ab Version V2.10.1025.00

N010 $IF V.E.trajektorie.name != 

N020 V.E.name = V.E.trajektorie.name

N030 P1 = 0

N040 $WHILE P1 < V.E.trajektorie.nbr_points

N050 $IF V.E.trajektorie.points[P1].valid == TRUE

N060 G0 X = V.E.trajektorie.points[P1].point.x

Y = V.E.trajektorie.points[P1].point.y

Z = V.E.trajektorie.points[P1].point.z

N070 $ENDIF

N080 P1 += 1

N090 $ENDWHILE

N100 $ENDIF

N110 V.E.name = 

N120 M30

Mehr:

button Synchronisation des Zugriffs durch NC-Kanal


Synchronisation des Zugriffs durch NC-Kanal

Der Anwender erwartet einen Variablenzugriff (Lesen, Schreiben) in der zeitlichen Sequenz, wie im NC-Programm angegeben. Da die NC-Programmdekodierung in einer planerischen Phase zeitlich vor der eigentlichen Abarbeitung der NC-Befehle durchgeführt wird, darf ein Variablenzugriff nicht einfach während der Programmdekodierung durchgeführt werden, sondern muss zur der aktuellen Programmabarbeitung (Achsbewegung) synchron erfolgen. Dies wird folgendermaßen sichergestellt:

LESEN Beim Lesen wird die Dekodierung solange angehalten, bis die aktuelle Programmbearbeitung an der zuletzt dekodierten NC-Programmzeile angelangt ist (implizites FLUSH & WAIT, s. a. [PROG]). Da ein FLUSH & WAIT während bestimmter satzübergreifender NC- Funktionalitäten (z.B. aktiver Splineinterpolation, aktiver WRK) nicht erlaubt ist, ist auch ein synchrones LESEN während dieser Funktionalität nicht möglich.

SCHREIBEN Ein Schreibzugriff wird wie ein sonstiges NC-Kommando während der Dekodierung eingeplant und erst später bei der NC-Bearbeitung tat-sächlich durchgeführt.

Da diese Synchronisierung, insbesondere das Anhalten der Dekodierung bei einem Lesezugriff, unerwünschte Laufzeiteinflüsse hat, kann diese implizite Synchronisation bei der Definition der Variablen ausgeschaltet werden. Dies ist natürlich nur möglich, wenn der Zeitpunkt des Lesezugriffs nicht synchron zur Bearbeitung erfolgen muss bzw. dies durch einen expliziten Synchronisationspunkt (z.B. explizites FLUSH & WAIT) im NC-Programm sowieso sichergestellt ist.

Abbildung 3-1: Asynchroner/synchroner Zugriff der Dekodierung (DEC) und Abarbeitung (BAHN) über SPS-Treiber (HLD)

Die Ausgabe synchronisierter VE-Variablen erfolgt über die gleiche Schnittstelle wie die von Technologiefunktionen (M-/H-/T-Funktionen) mit der Synchronisationsart MOS. Der Anwender hat daher sicherzustellen, daß alle an dieser Schnittstelle anstehenden Daten von der SPS ausgelesen werden, da sonst die Synchronität zur Ausgabe im NC-Kanal nicht gewährleistet ist.


Oberfläche

Die Oberfläche hat Zugriff auf NC-Schnittstellen und NC-Daten über sogenannte HMI-Objekte. Das Protokoll des Zugriffs wird über eine DLL gekapselt, welche eine Windows-Applikation den Schreib-/Lesezugriff auf HMI-Objekte anbietet. Für die Oberfläche können automatisch entsprechend der Konfigurationsliste Schnittstellenobjekte angelegt werden, wenn dies für die Variable entsprechend konfiguriert ist.

Für jede angegebene Variable werden dann zwei Objekte angelegt, je eines für den Schreib- und eines für den Lesezugriff. Die findet unabhängig von den Zugriffsrechten des NC-Kanals statt, d.h. selbst wenn der NC-Kanal nur lesenden Zugriff auf die Variable hat (z.B. access_rights = READ_ONLY), kann die Oberfläche auch schreibend zugreifen. Bei einem Feld wird eine Oberflächenobjekt für jedes Feldelement angelegt.

Falls gewünscht kann das Format der Namen der Oberflächenobjekte durch Angabe entsprechender Schablonen in der Liste beliebig angepasst werden (ab Version V254). Hierbei sind als Platzhalter %s für den Namen und bei einem Feld nachfolgend zusätzlich %d für den Index anzugeben.

Bezeichner | Bedeutung | Defaultwert
name_rd_global_array | Lesen bei globalem Feld | cnc_ve_ %s _rd[ %d ]
name_wr_global_array | Schreiben bei globalem Feld | cnc_ve_ %s _wr[ %d ]
name_rd_channel_array | Lesen bei kanalspezifischem Feld | mc_ve_ %s _rd[ %d ]
name_wr_channel_array | Schreiben bei kanalspezifischem Feld | mc_ve_ %s _wr[ %d ]
name_rd_global | Lesen bei globalen Variablen | cnc_ve_ %s _rd
name_rd_global | Schreiben bei globalen Variablen | cnc_ve_ %s _wr
name_rd_channel | Lesen bei kanalspezifischen Variablen | mc_ve_ %s _rd
name_wr_channel | Schreiben bei kanalspezifischen Variablen | mc_ve_ %s _wr

Beispiel: Vergabe der Namen für die Oberflächenschnittstelle

# ***************************************

#

# ***************************************

#

name_rd_global_array cnc_test1_%s_rd[%d]

name_wr_global_array cnc_test1_%s_wr[%d]

name_rd_channel mc_test2_%s_rd

name_wr_channel mc_test2_%s_wr

...

var[0].name G_ARRAY5

var[0].index 0

var[0].type SGN32

var[0].scope GLOBAL

var[0].synchronisation FALSE

var[0].access_rights READ_WRITE

var[0].array_size 5

var[0].size 4 # 4 Byte pro Element

var[0].create_hmi_interface TRUE # HMI-Objekt wird angelegt

#

var[1].name L_BOOLEAN

var[1].index 1

var[1].type BOOLEAN

var[1].scope CHANNEL

var[1].synchronisation FALSE

var[1].access_rights READ_WRITE

var[1].array_size 1

var[1].size 1 # 4 Byte pro Element

var[1].create_hmi_interface TRUE # HMI-Objekt wird angelegt

Durch obigen Auszug aus der Konfigurationsliste werden implizit folgende HMI-Objekte angelegt:

cnc_test1_G_ARRAY5_rd[0]

cnc_test1_G_ARRAY5_wr[0]

cnc_test1_G_ARRAY5_rd[1]

cnc_test1_G_ARRAY5_wr[1]

cnc_test1_G_ARRAY5_rd[2]

cnc_test1_G_ARRAY5_wr[2]

cnc_test1_G_ARRAY5_rd[3]

cnc_test1_G_ARRAY5_wr[3]

cnc_test1_G_ARRAY5_rd[4]

cnc_test1_G_ARRAY5_wr[4]

mc_test2_L_BOOLEAN_wr

mc_test2_L_BOOLEAN_rd


SPS

Nach Hochlauf der Steuerung erhält das SPS-Run-Time-System Zugriff auf die gemeinsamen Speicherbereiche für VE Variablen zwischen CNC und SPS. Diese werden in kanalspezifische und einen globalen Speicherbereich unterschieden.

pVE[iChannelNr]^.addr

pVEGlob^.addr

Um den Zugriff auf die Speicherbereiche zu vereinfachen, werden in einer zusätzlichen Bibliothek TcCncUtilities.lib Funktionen angeboten, welche die Verwaltung der angelegten VE Variablen übernehmen und Zugriffe auch über den Namen ermöglichen.

Falls externe Variablen mit benutzerdefinierten Variablentypen konfiguriert sind, kann die SPS-Bibliothek TcCncUtilities.lib nicht verwendet werden. In diesem Fall empfiehlt es sich die Variablenstrukturen in der PLC nachzubilden und mit Hilfe der Zeiger pVE[iChannelNr]^.addr bzw. pVEGlob^.addr direkt auf den jeweiligen V.E Variablenspeicher zuzugreifen (s. Programmierbeispiel 2).

Vor Verwendung der Bibliothek muss eine Grundinitialisierung seitens der SPS durchgeführt werden. Hierbei wird die bei der CNC Konfiguration angegebene Formatbeschreibung der externen Variablen automatisch durch die SPS übernommen.

Dazu tauschen die CNC und die SPS während der Initialisierung die Variablen Beschreibungen aus. Der Speicherbereich der externen Variablen wird während der Initialisierung abgelöscht (Werte = 0).

Zusätzlich werden dabei die einzelnen Formate der Variablen auf ihre Korrektheit hinsichtlich des Speicherindex und des Speicherbereiches geprüft und bei auftretenden Fehlern Meldungen auf dem Logger ausgegeben. Um den Zugriff auf nichtdefinierte Speicherbereiche bei Feldern zu verhindern, wird eine Überprüfung der Zieladresse durchgeführt. Dazu wird die Größe des Zieldatentyps an die jeweilige Bibliotheksfunktion übergeben (siehe Bespiel).

Für den lesenden und schreibenden Zugriff auf die externe Variablen bzw. Arrays von externen Variablen werden Zeiger auf die erwartenden Datenstrukturen erzeugt und mit der jeweils passenden Adresse aus dem HLI Speicherbereich initialisiert Über den dereferenzierten Pointer kann dann direkt auf die Variable strName zugegriffen werden, z,.B.:

POINTER_TO_BOOL = VeBool(1, Peter, 0);

POINTER_TO_BOOL^=23;

Funktion | INPUT | RETURN | Bedeutung
VeInitialisation() |  | BOOL Status | Initialisiert die Bibliothek damit VE Variablen in der SPS verwendet werden können.
 |  | Status [true/false] | Status der Initialisierung der Bibliothek für Zugriff auf externe Variablen. Solange dieser Wert false ist kann nicht auf VE Variablen zugegriffen werden.
Ve<DatenTyp>() | UINT iChannel STRING strVeName UINT ISizeArrayByte | POINTER TO <DatenTyp> pDatatype | Funktionen liefern die Speicheradresse einer Variablen mit dem Typ <DatenTyp> , welche über die Angabe eines Namens identifiziert werden. DatenTyp = [Uns08, Sgn08, Uns16, Sgn16, Uns32, Sgn32, Real32, Real64, String]
 | IChannel [1 .. nChannel] |  | Kanalnummer in welchem die Variable strName deklariert wurde.
 | StrVeName [String] |  | Name der Variablen auf die zugegriffen werden soll (nicht größer als 20 Zeichen)
 | IsizeArrayByte [sizeof(Ziel_Pointer^)] |  | Größe des erwartenden Arrays zur Überprüfung des korrekten Speicherzugriff. Wenn kein Array erwartet wird ist dieser Wert mit 0 zu initialisieren.
 |  | PDatatype [pIntArray ] | Adresse zum Zugriff auf die VE Variable mit dem Namen strVeName .

Das folgende Beispiel bezieht sich auf die Beispielkonfiguration der VE Variablen aus dieser Dokumentation (s.o. Kapitel 2.3). Vor der Verwendung des VE Zugriffs in einem Programm muss das HLI Interface erfolgreich initialisiert (siehe [HLI]), die TcCncUtilities.lib Bibliothek im gewünschten Projekt eingefügt sein und folgende Schritte durchgeführt werden:

Programmierbeispiel
Zugriff VE-Variablen in der SPS (VeExampleDoku.pro)

VAR

VEInitialisationDone : BOOL;

I : INT;

pCHANNEL_WR : POINTER TO ARRAY [0..9] OF INT := 0;

pGLOBAL_SWR : POINTER TO DINT := 0;

END_VAR

(* Zugriff auf VE Variablen in der SPS *)

IF VEInitialisationDone = FALSE THEN

VEInitialisationDone := VeInitialisation();

IF VEInitialisationDone = TRUE THEN

pCHANNEL_WR := VeSgn32(1,'CHANNEL_WR, SIZEOF(pCHANNEL_WR^));

pGLOBAL_SWR := VeSgn16(1,'GLOBAL_SWR', 0);

ELSE

RETURN;

END_IF

END_IF

(* Jetzt kann direkt schreibend und lesend auf die Variable

zugegriffen werden. Zum Testen:

- Inhalt der Variable pChannel im Plc Open überprüfen -> 801..802.....

- Zum Test im System Manager V.E.GLOBAL_SWR=20 als einzelnen Handsatz ausführen um aus der CNC diese VeVariable zu schreiben.

- Dadurch sollte anschließend die pChannel Variable automatisch in der SPS auf0 gesetzt sein. *)

IF pCHANNEL_WR <> 0 AND pGLOBAL_SWR <> 0 THEN (* reading access*)

IF pGLOBAL_SWR^ = 20 THEN (* reading access*)

FOR I:=0 TO 9 BY 1 DO

pCHANNEL_WR^[I] := 0; (* writing access*)

END_FOR

ELSE

FOR I:=0 TO 9 BY 1 DO

pCHANNEL_WR^[I] := 800+I; (* writing access*)

END_FOR

END_IF

pGLOBAL_SWR1^:=0; (* writing access*)

Dieses PLC-Beispiel zeigt, wie die V.E Variablen durch Nachbilden der Variablenstrukturen in der PLC verwendet werden können. Vor dem Zugriff auf die Zeiger pVE[iChannelNr]^.addr bzw. pVEGlob^.addr muss das HLI Interface erfolgreich initialisiert sein (s. [HLI - 15.1 Zugriff auf das HLI]).

Programmierbeispiel 2
Zugriff VE-Variablen in der SPS ohne TcCncUtilities.lib Bibliothek
(ab Version V2.10.1025.00)

Definition der Variablenstrukturen für die V.E.Variablen:

TYPE VECTOR_T :

STRUCT

x : LREAL;

y : LREAL;

z : LREAL;

END_STRUCT

END_TYPE

TYPE TARGET_POINT_T :

STRUCT

point : VECTOR_T;

valid : BOOL;

END_STRUCT

END_TYPE

TYPE TRAJEKTORIE_T :

STRUCT

nbr_points : DINT;

name : STRING(127);

points : ARRAY [0..9] OF TARGET_POINT_T;

END_STRUCT

END_TYPE

Definition der Strukturen für den kompletten, belegten V.E.Speicherbereich:

TYPE VE_GLOBAL:

STRUCT

var_global_1 : DINT;

END_STRUCT

END_TYPE

TYPE VE_CHAN_1:

STRUCT

var_chan_1 : DINT;

array_chan_1 : ARRAY [0..19] OF INT;

name : STRING(127);

Trajektorie : TRAJEKTORIE_T;

END_STRUCT

END_TYPE

PLC-Programm zum Zugriff auf die V.E.Variablen:

PROGAM V_E

VAR

p_ve_chan_1 : POINTER TO VE_CHAN_1;

END_VAR

p_ve_chan_1 := ADR (pVe[1]^.addr^.AHLI_UNS32_Data);

IF (p_ve_chan_1^.name = )

THEN

p_ve_chan_1^.trajektorie.name := My Path!

p_ve_chan_1^.trajektorie.nbr_points := 2;

p_ve_chan_1^.trajektorie.points[0].valid := TRUE;

p_ve_chan_1^.trajektorie.points[0].point.x := 100.0;

p_ve_chan_1^.trajektorie.points[0].point.y := 200.0;

p_ve_chan_1^.trajektorie.points[0].point.z := 300.0;

p_ve_chan_1^.trajektorie.points[1].valid := TRUE;

p_ve_chan_1^.trajektorie.points[1].point.x := 200.0;

p_ve_chan_1^.trajektorie.points[1].point.y := 400.0;

p_ve_chan_1^.trajektorie.points[1].point.z := 600.0;

END_IF;


Konfigurationssyntax bis einschließlich V253

Bis einschließlich Version V253 erfolgt die Konfiguration der Variablen eines Kanals in der textuellen ASCII Liste (ext_var*.lis) wie folgt:

Beispiel:

# ****************************************

#

# Externe Variablen V253

#

# ****************************************

#

anzahl_belegt 2

#

var[0].name GLOBAL_SWR

var[0].index 0 # Startposition

var[0].var_typ 16 # SGN16_Array

var[0].mode 0x1 # 1 : VE_SYNCH, 2 : VE_ASYNCH

var[0].access 0x0202 # 0x100 : local, 0x200 global

# 0x1 : read, 0x2 : write

var[0].max_element 0 # Arraygrösse

var[0].offset 2 # 2 Byte pro Element

var[0].kennung 0 # Unbenutzt

#

var[1].name CHANNEL_WR

var[1].index 0 # Startposition

var[1].var_typ 8 # SGN32

var[1].mode 0x2 # 1 : VE_SYNCH, 2 : VE_ASYNCH

var[1].access 0x0101 # 0x100 : local, 0x200 global

# 0x1 : read, 0x2 : write

var[1].max_element 10 # Arraygrösse

var[1].offset 4 # 4 Byte pro Element

var[1].kennung 0 # Unbenutzt

#

Ende

Die Elemente haben folgende Bedeutung:

Bezeichner

Wertebereich

Default

Bedeutung

anzahl_belegt

[0; MAX_UNS16]

0

Bei lückenloser Belegung von var[i].* wird hier der Index der zuletzt definierten Variable +1 eingetragen (ilast+1).

Bei lückender Belegung von var[i].* wird hier der höchste Index der definierten Variablen +1 eingetragen (imax+1).

var[i].*

i:= [0; 214]

Datensätze zur Definition der Variablen

name

ASCII-String

Über den Namen wird die Variable identifiziert. Aus diesem wird ein Gesamtname für den NC-Kanal und die Oberfläche zusammengesetzt (z.B. V.E.<name>).

Gross- und Kleinbuchstaben werden unterschieden.

index

[0; MAX_SNG32]

-1

Der Index legt die Position im Speicher fest, an welcher die Variable abgelegt wird. Der gesamte Speicher ist dabei als Feld von 24 Byte grossen Einheiten aufgebaut.

Ein Index von 1 zeigt an, dass der Eintrag nicht belegt ist.

var_typ

2  BOOLEAN,
3 - UNS08,
4 - SGN08,
5 - UNS16,
6 - SGN16,
7 - UNS32,
8 - SGN32;
9 - REAL64,
10 - STRING

12 BOOLEAN Array,
13 - UNS08 Array,

UNS32

Der Typ gibt den Datentyp der Variablen an. Neben elementaren Datentypen (SGN08, ..., REAL64, ARRAY_OF_SGN08, ...) existiert der Datentyp String, welcher derzeit inklusiv Endmarke 24 Byte umfasst.

mode

1 - synchron,
2 - asynchron

1

Für Optimierungen kann der Zugriff auf Variablen während der Dekodierung auch nicht-synchron zur aktuellen Programmbearbeitung erfolgen.

access

0x100  CHANNEL,
0x200  GLOBAL,

0x1  READ
0x2 - WRITE

0x103

Beim Gültigkeitsbereich wird zwischen einem kanalspezifischen und einem kanalübergreifenden, globalen unterschieden.

Per Default ist ein Schreib-/Lesezugriff (0x3) auf die Variablen möglich, welcher über den Zugriffsschutz eingeschränkt werden kann.

max_element

[0; MAX_UNS16]

0

Ist die Variable nicht als Feld ausgelegt, so muss die Feldgrösse mit 0 angegeben werden. Ansonsten wird an dieser Stelle die Gesamtgrösse des Feldes festgelegt.

offset

[0; MAX_UNS32]

4

Gibt die Grösse der Variablen an inclusiv evtl. Alignmentbytes, d.h. die Differenz zweier nachfolgenden Feldelemente. Je nach Rechnerarchitektur und Alignmentstrategie kann sich diese Grösse aus den realen Nutzdaten und zusätzlichen Alignmentbytes zusammensetzen.

kennung

[0; MAX_SGN16]

0

Nicht benutzt. Frei vergebbare anwenderspezifische Kennung.