Grundlagen der Programmierung für Robotik - oth-aw.de · • Mathematik (Koordinatensysteme,...

BMBF-Verbundprojekt OTH mind

Grundlagen der Programmierung für Robotik

2017

Prof. Dr.-Ing. Manfred Beham


Teil 1: Einführung

Begriffe, Typen von Robotern und Anwendungsgebiete


1. Einführung

• Literatur

• Normen und Richtlinien

• Einführung

• Robotik als interdisziplinäres Fachgebiet

• Geschichte

• Entwicklung erster Industrieroboter

• Entwicklung heutiger Industrieroboter

• Einteilung der Roboter und Anwendungsfelder

• Einteilung der Handhabungsgeräte (VDI) • Abgrenzung, Begriffsdefinition • Einteilung nach Einsatzgebieten • Industrieroboter • Serviceroboter • Geländeroboter • Neue Anwendungsfelder

• Einsatzzahlen und Märkte von Industrieroboter • Märkte für Serviceroboter


Literatur

• Weber, W.:

Industrieroboter: Methoden der Steuerung und Regelung

München, Wien: Hanser, 2002

• Hesse, S.:

Industrieroboterpraxis.

Wiesbaden: Vieweg, 1998

• Siegert, H.-J.; Bocionek, S.:

Robotik: Programmierung intelligenter Roboter.

Berlin: Springer, 1996

• Dietmar Steinpichler und Horst Kargl

Projektabwicklung mit UML und Enterprise Architect

SparxSystems Software 2012

• Linnemann

Vorlesungsmanuskript WiSe 2016/17 Robotertechnik.

Beuth Hochschule für Technik Berlin, Fachbereich VI – Informatik und Medien


Normen

• DIN EN 775: Industrieroboter – Sicherheit. Berlin: Beuth, 1993

• DIN 66 312: Industrieroboter – Programmiersprache, Industrial Robot Language

(IRL)

Berlin: Beuth, 1996

• DIN EN ISO 8373: Industrieroboter – Wörterbuch. Berlin: Beuth, 1996

• DIN EN ISO 9787:Industrieroboter – Koordinatensysteme und Bewegungsnomenklatur.

Berlin: Beuth, 1999


Richtlinien

• VDI 2740 Blatt 1: Mechanische Einrichtungen in der Automatisierungstechnik –

Greifer für Handhabungsgeräte und Industrieroboter.

Düsseldorf: VDI-Verlag, 1995

• VDI 2853: Sicherheitstechnische Anforderungen an Bau, Ausrüstung und Betrieb

von Industrierobotern. Düsseldorf: VDI-Verlag

• VDI 2861: Montage- und Handhabungstechnik – Kenngrößen für

Blatt 1 … 3 Industrieroboter, verschiedene …

Düsseldorf: VDI-Verlag


Interdisziplinäres Wissensgebiet:

Robotertechnik

Tangierte Fachgebiete:

• Maschinenbau (mechanischer Aufbau, Konstruktion)

• Elektrotechnik (Antriebe/Aktoren, Sensoren, Signalverarbeitung,

Steuerung)

• Steuerungs- und Regelungstechnik

• Mathematik (Koordinatensysteme, Kinematik)

• Informatik (Programmierung, Simulation)

• Produktionstechnik

• KI (Bild-, Spracherkennung, automatisiertes Lernen, Multi-Agenten, …)

• Psychologie, Arbeitswissenschaften und Kognitionswissenschaften

• Biologie (Kybernetik)


Historische Entwicklung:

Eine Auswahl

• 100 Heron von Alexandria: Entwürfe für Automatentheater

• 1352 Automatische Uhren mit Figurenwerk, z.B. am Straßburger Münster

• um 1700 Musikspielende Puppen (Flötenspieler, Tamburinspieler, künstliche

Ente)

• 1805 J.M. Jacquard: Mit Lochkarten gesteuerter Webstuhl

-> erster spezialisierter Industrieroboter

• 1921 Im Science-Fiction-Theaterstück „Rossum‘s Universalroboter“

von Karel Capek taucht das erste mal der Begriff Roboter auf.

(slawisch „rabota“ = arbeiten)

• 1946 USA, G.C. Devol: Steuergerät zur magnetischen Aufzeichnung

elektrischer Signale: Die Signale konnten später zur Steuerung

mechanischer Geräte (roboterähnliche Maschinen) benutzt werden.

(mehrere Patente)

• 1952 Prototyp einer NC-Maschine am MIT, Entwicklung der

Programmiersprache APT



Eine Auswahl

• 1954 England, C.W. Kenward reicht Patent eines Roboters ein. USA, G.C. Devol arbeitet an dem programmierten Transport von Gegenständen; erhält 1961 dafür ein Patent

• 1959 Erster kommerzieller Roboter der Fa. Planet Corporation für einfache Aufgaben, z.B. Punktschweißen

• 1960 Erster Roboter der Fa. Unimate (basiert auf Arbeiten von Devol) Der Roboter wurde hydraulisch angetrieben und von einem Computer nach dem Prinzip der NC-Technik gesteuert

• 1961 Erster Roboter der Fa. Unimate bei Ford installiert

• 1971 Deutschland: Erster Roboter bei Daimler-Benz

• 1975 SIGMA Roboter von Olivetti

• 1978 Einführung der PUMA Serie (Programmable Universal Machine for Assembly). Elektrisch angetrieben, von General Motors, gebaut von Fa. Unimation

• 1979 Yamanaski-Universität, SCARA-Prinzip (Selective Compliance Assembly)



Eine Auswahl

• 1980 Entwicklungsarbeiten zum Greifen und Fügen mit

Kameraunterstützung.

• 1985 Beginn der Entwicklung autonomer Roboter.

• 1992 Beginn der Entwicklung von Servicerobotern.

• 1997 Erste Weltmeisterschaft im Roboter-Fußball, Tokio.

• 1998 Stanford Research Institute entwickelt einen mobilen experimentellen

Roboter (Shakey) mit Kamera und taktilen Sensoren.


Robotik in der SciFi-Literatur

Isaac Asimov Gesetze

1. Ein Roboter darf keinen Menschen verletzen.

2. Ein Roboter muss den Anweisungen gehorchen, die

ihm von Menschen gegeben werden, außer wenn diese

dem ersten Gesetz widersprechen.

3. Ein Roboter muss seine eigene Existenz solange zu

sichern versuchen, wie dies nicht dem ersten oder

zweiten Gesetz widerspricht.


Einteilung der Handhabungsgeräte nach VDI

Nach VDI 2860 Blatt 1 bilden Industrieroboter eine Untergruppe der

Handhabungseinrichtungen. Unter Handhaben sind alle Vorgänge zu verstehen,

• bei denen ein Objekt in eine definierte Lage im Raum gebracht oder gehalten

wird,

• oder bei denen mit dem Objekt eine definierte Bewegung ausgeführt wird

Handhabungsger

äte

Manuell

gesteuert

Programm

gesteuert

Fest

programmiert

Frei

programmierbar

Industrieroboter


Abgrenzung des Begriffs

Industrieroboter

• Ein Industrieroboter ist keine NC-Maschine (Numerically Controlled

Machine)

• Hauptaufgabe NC-Maschine:

Formgebende Bearbeitung eines Werkstückes

• Hauptaufgabe Industrieroboter:

Handhabung von Werkstücken, Montage, Bearbeitung

• Die Übergänge sind jedoch fließend!

• Ein Industrieroboter ist kein Teleoperator

wie er z.B. in Kernkraftwerken eingesetzt wird: Die Bewegung eines

Teleoperators wird unmittelbar vom Menschen gesteuert.

• Ein Industrieroboter ist kein Einlegegerät

Das Einlegegerät ist eine "mit Greifern ausgerüstete

Handhabungseinrichtung, die vorgegebene Bewegungsabläufe nach einem

festen Programm abfährt".


Begriffsdefinition

Industrieroboter (IR)


Einteilung nach Einsatzgebieten

• Industrieroboter Arbeiten in Fabriken und Lagerhallen (künstliche Umgebung):

Schweißroboter, Lackierroboter, Montageroboter, …

• Serviceroboter Arbeiten in von Menschen bevölkerten Gebieten:

Putzroboter, Rasenmäher, Museumsführer

• Geländeroboter Arbeiten in rauer Umgebung oder an von Menschen nicht zugänglichen

Orten:

Tiefsee, Weltraum, Kernkraftwerke, Kanalreinigung, …

• Autonome Roboter / Agentensysteme (Forschung)

Fußballspieler, Laufmaschinen, Artifical Life, Androide


Industrieroboter


Serviceroboter


Interaktive Serviceroboter


Geländeroboter


Neue Anwendungsfelder

Sanierung



Medizin



Freizeit


Der RoboCup


Einsatz von Industrierobotern

- Deutschland


Kundenbranchen der Industrieroboter

- Deutschland


Einsatz von Serviceroboter

- international


Teil 2: Kinematik (Einführung)

Koordinatensysteme, Transformation, Bewegungssteuerung


2. Kinematik

• 2.1 Koordinaten und Transformation

• 2.2 Beschreibung einer Roboterstellung

• 2.3 Die kinematische Kette

• 2.4 Die kinematische Vorwärtstransformation

• 2.5 Die kinematische Rückwärtstransformation

• 2.3 Armbewegung


Literatur

• Linnemann

Vorlesungsmanuskript WiSe 2016/17 Robotertechnik.

Beuth Hochschule für Technik Berlin, Fachbereich VI – Informatik und Medien

• VAL3 Referenzanleitung

Stäubli, Faverges 2005

D28056202B - 06/2005


2.1 Koordinaten und Transformation

Koordinatensysteme und Vektoren

Wir benutzen kartesische Koordinatensysteme mit drei senkrecht zueinander stehendenKoordinatenachsen. Dabei gilt die Rechtsschraubenregel. In der Robot ik werden zwei Arten von Vektorenunterschieden:

Freie Vektoren (Richtungsvektoren) lassen sich im Raum beliebig verschieben und benöt igenkeinen explizit en Ursprung des Koordinatensystems.Ortsvektoren sind relat ive Posit ionsangaben und gehen immer von einem Ursprung desKoordinatensystems aus.

Beispie le :

1) Freier Vektor Geschwindigkeit : v

vx

vy

vz

vx vy vz T

2) Ortsvektor (benöt igt Koordinatensystem)

p

x

y

z

x y z( )T



Homogene Koordinaten/Matrizen

Um jede Form der Vektor-/Koordinatentransformat ion einheintlich durch eine Matrix mal VektorMult iplikat ion darstellen zu können, werden Vektoren durch eine vierte, konstante Komponente erweitert .Homogene Matrizen (4x4) werden um eine vierte Zeile (0, 0, 0, 1) erweitert.

HomogenerOrtsvektor:

p

x

y

z

1

Pkt x y z ( ) x y z 1( )T

Alg. Transformat ion:

p´ T p

m11

m21

m31

0

m12

m22

m32

0

m13

m23

m33

0

tx

ty

tz

1

x

y

z

1

x m11 y m12 z m13 tx

x m21 y m22 z m23 ty

x m31 y m32 z m33 tz

1



Verschiebung (Translation)

Translat ion um Vektor x y z( )T

: Trl x y z ( )

1

0

0

0

0

1

0

0

0

0

1

0

x

y

z

1

x'

y'

x

y

P



Drehung um die z-Achse (Rotation)

x'

y'

z'

P

θZ

Rotation um die z-Achse um den Winkel ?: Rotz ( )

cos ( )

sin ( )

0

0

sin ( )

cos ( )

0

0

0

0

1

0

0

0

0

1



Drehung um die x-Achse oder y-Achse

Rotation um die x-Achse um den Winkel ?: Rotx ( )

1

0

0

0

0

cos ( )

sin ( )

0

0

sin ( )

cos ( )

0

0

0

0

1

Rotation um die y-Achse um den Winkel ?: Roty ( )

cos ( )

0

sin ( )

0

0

1

0

0

sin ( )

0

cos ( )

0

0

0

0

1



Koordinatentransformation Beispiele

Beispiel: Rotationvon 45° um die z-Achse

p Pkt 1 1 0 ( ) R Rotz 45°( )

0.7

0.7

0

0

0.7

0.7

0

0

0

0

1

0

0

0

0

1

p´ R p( )T

0 1.4 0 1( ) R 1

Beispiel: Translation (0.5, 0.5, -0.5)

p Pkt 1 1 0 ( ) T Trl 0.5 0.5 0.5 ( )

1

0

0

0

0

1

0

0

0

0

1

0

0.5

0.5

0.5

1

p´ T p( )T

1.5 1.5 0.5 1( ) T 1



Aufeinanderfolgende Transformationen (Verkettung)

Der Punkt P1 wird durch T1 in den Punkt P2 und anschließend durch T2 in den Punkt P3 t ransformiert:

P2 T1 P1

P3 T2 P2 T2 T1 P1

P3 Tres P1 Tres T2 T1

Beispiel T Trl 1 0 0 ( ) R Rotz 45°( ) pT

1 1 0 1( )

p´ R T p

0.7

2.1

0

1

R T

0.7

0.7

0

0

0.7

0.7

0

0

0

0

1

0

0.7

0.7

0

1


2.2 Beschreibung einer Roboterstellung

Zweifach Gelenk-Knickarm

Beispiel: Zweifach Gelenk Knickarm

Armlängen: r1 10 r2 8 1 45° 2 90 ° P2 Pkt 0 0 0 ( )

Transformation: Tg 1 2 Rotz 1 Trl r1 0 0 Rotz 2 Trl r2 0 0

i 0 2 P1 Rotz 1 Trl r1 0 0 P2 P0 Tg 1 2 P2

20 10 0 10 20

20

10

10

20

P0T

12.7 1.4 0 1( )

2.1.4 Beschreibung der Orientierung



Orientierung eines Körpers im Raum

Die Orient ierung eines Körpers enthält drei Freiheit sgrade. Sie kann mathemat isch auf verschiedene Artenformuliert werden.



Drehung um raumfeste Achsen

• Zunächst betrachten wir die Orientierung durch drei aufeinanderfolgende Drehungen

um die Achsen eines raumfesten Koordinatensystems. In Bezug auf die Handachsen

spricht man oft von Drehen, Beugen und Neigen (DBN-System).

• Neigung: Drehung um die x-Achse um den Winkel ϕ x

• Beugung: Drehung um die y-Achse um den Winkel ϕ y

• Drehung: Drehung um die z-Achse um den Winkel ϕ z



Drehung eines Werkstücks um raumfeste Achsen x, y und z

Beispiele:



Drehung eines Werkstücks um raumfeste Achsen x, y und z



Bezugssysteme

• Unter Bezugssystemen versteht man die Verwendung mehrerer

Koordinatensysteme bei der Beschreibung von Roboterteilen und

Werkstücken. Jedes Bezugssystem ist einem Körper zugeordnet; das sind

Armteile, Werkzeuge, Werkstücke oder Hindernisse. Der gesamte

Roboterarm kann als kinematische Kette betrachtet werden, wobei jedes

Armteil durch ein zugehöriges Koordinatensystem dargestellt wird, das fest

mit dem Armteil verbunden ist und es bezüglich Lage und Orientierung

eindeutig beschreibt.

• Die Verwendung von Bezugssystemen ist höchst charakteristisch für die

Robotik. Die Robotersteuerungen und die Robotersprachen sind darauf

eingerichtet, mit unterschiedlichen Bezugssystemen zu arbeiten.

Koordinatensysteme heißen in diesem Zusammenhang auch frames.



Bezugssysteme (Koordinatensysteme) in der Robotik

• Weltkoordinaten (world frame): Fest mit der Welt (Fußboden) verbunden.

• Basiskoordinaten (base frame): Mit dem Sockel des Roboters verbunden,

die z-Achse ist meist mit der Achse des ersten Drehgelenks verbunden.

• Anwenderkoordinaten (user frame): Mit der Aufnahme für Werkstücke

verbunden, oft relativ zu Weltkoordinaten.

• Werkstückkoordinaten (object frame): Mit einem Werstück verbunden,

relativ zu Anwenderkoordinaten.

• Handflanschkoordinaten (toolO frame): Mit dem Handflansch verbunden,

mitbewegt und über die kinematische Kette der Gelenke relativ zu den

Basiskoordinaten festgelegt.

• Werkzeugkoordinaten (tool frame): Relativ zu den Handflanschkoordinaten

definiert.



Übliche Bezugssysteme (Koordinatensysteme) in der Robotik



Mehrere Koordinatensysteme als Bezugssysteme



Systematische Indizierung

PA der Punkt P in Koordinaten des Bezugssystems A.

PB der selbe Punkt P in Koordinaten des Bezugssystems B.

Wenn eine T ransformat ion TA_B das Koordinatensystem KA in das System KB überführt , dann

t ransformiert TA_B auch Punkte von der Darstellung in B-Koordinaten in die Darstellung in

A-Koordinaten.

KB TA_B KA

PA TA_B PB

Die inverse Matrix TA_B

-1 wirkt genau umgekehrt : TA_B1

TB_A

KA TA_B 1KB

PB TA_B 1PA



Übungsbeispiel zu Koordinatensysteme

In einer Fertigungsstraße steht ein Lackierroboter hinter einer Autokarosserie. Die Bezüge zwischen Weltkoordinaten, Basiskoordinaten, Effektorkoordinaten und Objektkoordinaten sind wie folgt gegeben:

• Das Basiskoordinatensystem geht aus den Weltkoordinaten hervor durch eine Translation um (20; 30; 0).

• Das Objektkoordinatensystem geht aus den Weltkoordinaten hervor durch eine Rotation um 180° um die z-Achse und eine anschließende Translation um (350; 0; 130).

• Das Effektorkoordinatensystem geht aus den Basiskoordinaten hervor durch eine Rotation um 135° um die y-Achse und eine anschließende Translation um (150; 0; 125).

• Ein Punkt P ist in Objektkoordinaten gegeben durch PO = (200; 25; 10).

Bestimmen Sie die Koordinaten des Punktes P in Weltkoordinaten, Basiskoordinaten und Effektorkoordinaten!


2.3 Die kinematische Kette

Grundlegende Fragestellung der Robotik

• Kartesische Koordinaten (point ) sind x, y, z sowie die drei Orientierungswinkel, gemessen in einem zur Roboterzelle gehörenden Koordinatensystem. Beim Entwurf des Bearbeitungsvorganges wird man immer in kartesischen Koordinaten arbeiten und denken. Die kartesischen Koordinaten sind meist die bevorzugten Koordinaten für den Menschen beim Programmiervorgang.

• Gelenkkoordinaten (joint ) Der Roboter erreicht sein Ziel nur deshalb, weil jedes Gelenk exakt auf den richtigen Winkel bzw. die richtige Länge gefahren wird. Die Robotersteuerung auf der maschinennahen Ebene muss bei einer Bewegung den Servomotoren des Roboters korrekte Zielangaben machen und diese müssen im internen Koordinatensystem der Servomotoren formuliert sein. Dieses sind die Gelenkkoordinaten und auf der unteren Steuerungsebene können nur sie benutzt werden. Die Gelenkkoordinaten heißen auch Gelenkwinkel, Maschinenkoordinaten oder Achskoordinaten. Die Robotersprachen enthalten sowohl Bewegungsbefehle die kartesische Koordinaten benutzen (Normalfall) als auch Bewegungsbefehle, die Gelenkkoordinaten benutzen (seltener genutzt).



Die kinematischen Transformationen

Die Umrechnung zwischen kartesischen und Gelenkkoordinaten heißen kinematische Transformationen. Wenn die Steuerung einen kartesisch programmierten Punkt anfährt, muss sie von den kartesischen Koordinaten auf Gelenkkoordinaten transformieren (umrechnen). Bei einer CP-Bewegung muss das in sehr kurzen Abständen geschehen, um die Bahn kontinuierlich unter Kontrolle zu halten. Möchte man dagegen für einen vorgegebenen Satz von Gelenkwinkeln nachrechnen, wo der TCP sich befinden wird, wenn diese Gelenkkoordinaten angefahren sind braucht man eine Transformation von Gelenkkoordinaten auf kartesische Koordinaten.

Zur Unterscheidung benutzt man folgende Namensregelung:

• Die Umrechnung von Gelenkkoordinaten auf kartesische Koordinaten heißt kinematische Vorwärtstransformation.

• Die Umrechnung von kartesischen Koordinaten auf Gelenkkoordinaten heißt kinematische Rückwärtstransformation oder auch inverse kinematische Transformation.



Die Armteile des Roboters als kinematische Kette

• Die Armteile eines Roboters als kinematische Kette, in diesem Beispiel

6 Armteile (N=6)

Abbildung 8. Die Armteile eines Roboters als kinematische Kette, in diesemBeispiel 6 Armteile (N=6).


2.4 Die kinematische Vorwärtstransformation

Die mathematische Transformation

• Bei N Gelenken nennen wir die Gelenkkoordinaten θ 1 ... θ N gegeben,

wobei dies je nach Bauart des Gelenks ein Winkel oder ein Weg ist. Position

und Orientierung des Effektors (Hand) sind x, y, z, ϕ x, ϕ y, ϕ z und werden

berechnet.

1

2

3

.

.

N

x

y

z

x

y

z



Die Konventionen von Denavit und Hartenberg (1)

• Jedes Armteil enthält ein Koordinatensystem Kn, das man sich fest mit dem Armteil n

verbunden denkt und das die Stellung des Armteiles genau beschreibt. Jeder

Übergang auf das nächste Armteil n+1 wird durch eine Transformationsmatrix An+1

dargestellt. Diese Transformationsmatrix beschreibt die Stellung eines Armteiles in

Bezug auf das Armteil, an dem es montiert ist. (Vorgänger). Für einen N-achsigen

Roboter sind die Koordinatensysteme der Armteile K1, K2 … KN:

Transformation von Armteil n-1 zu Armteil n:Kn-1 => Kn := An

Dann gilt für die gesamte Ket te: K1 A1 K0

K2 A2 K1

...

KN AN KN 1

Wenn man die Ki schrittweise ersetzt kann man zusammenfassen:

KN AN A2 A1 K0



Die Konventionen von Denavit und Hartenberg (2)

Für die Transformat ion von Punktkoordinaten gilt :

P0 A1 P1

P1 A2 P2

...

PN 1 AN PN

Woraus wieder schrit tweise abgeleitet werden kann:

P0 A1 A2 AN PN

Das Matrizenprodukt A1A2A3 ... AN ist also die Transformation vom

Koordinatensystem KN auf die raumfesten Fußkoordinaten K0 und wird

hier als T0_N bezeichnet .

T0_N A1 A2 AN



Beispiel am 6 Gelenkarm Roboter

Gelenkwinkel: T

0 30 45 45 90 45 0( ) °

Transformationen: A1 Rotz 1 Trl 0 0 5 ( )

A2 Roty 2 Trl 0 0 8 ( )

A3 Roty 3 Trl 0 0 6 ( )

A4 Rotz 4 Trl 0 0 5 ( )

A5 Roty 5 Trl 0 0 3 ( )

A6 Rotz 6 Trl 0 0 2 ( )

Gesamt-T ransf.: T06 A1 A2 A3 A4 A5 A6

1

0.3

0

0

0

0

1

0

0.3

1

0

0

15.7

13.2

10.7

1

tp T06 T 15.7 13.2 10.7( )

x T06 90 °

y T06 0 °

z T06 165 °


2.5 Die kinematische Rückwärtstransformation

Die mathematische Transformation

• Die Rückwärtstransformation berechnet aus vorgegebenen kartesischen Koordinaten und Orientierung des Handflansches (oder Effektors) die Gelenkkoordinaten des Roboters. Bei N Gelenken sind also die Position und Orientierung des Effektors (Hand) x, y, z, ϕ x, ϕ y, ϕ z gegeben und die Gelenkwinkel θ 1 ... θ N werden berechnet.

x

y

z

x

y

z

1

2

3

.

.

N


2.5 Die kinematische Rückwärtstransformation

Probleme der inversen Transformation

• Mehrdeutigkeiten

Es existieren oft mehrere Lösungen, von denen nicht alle einer realen

Armstellung entsprechen. In manchen Fällen entspricht das Auftreten mehrere

Lösungen aber auch der geometrischen Realität. Zum Beispiel kann ein SCARA-

Roboter einen Raumpunkt immer in zwei Konfigurationen erreichen, nämlich mit

dem Ellenbogen nach links und nach rechts gedreht.

• Singularitäten

sind spezielle Situationen, in denen die mathematische Ermittlung der

Gelenkwinkel mit vorgegebener Geschwindigkeit des TCP nicht möglich ist. Sie

müssen durch zusätzliche Randbedingungen umgangen werden (config).


2.6 Armbewegung

Ausblick: Bewegungssteuerung

• Steuerung der Bewegungsgeschwindigkeit

Die Bewegung von einem Ausgangspunkt zu einem Zielpunkt mit vorgegebener

Geschwindigkeit (Bahngeschwindigkeit) in kartesischen Koordinaten.

• Bewegung auf einer definierten Kurve

Grundlegende geometrische Kurven (Gerade, Kreis) oder spezielle

Optimierungen (schnellst möglich) sind in der Software der Bewegungssteuerung

enthalten.

• Annäherung an eine Zielposition

Steuerung eines Geschwindigkeitsprofils bei Annäherung

• Interpolation zwischen einzelnen Bewegungen

Steuerung der Bewegung im Übergang von einem Bewegungsablauf zum

nächsten.


Teil 3: Daten und Datentypen

Elemente einer Programmiersprache: Variablen, Typen, Operatoren und Funktionen

(am Beispiel von Stäubli‘s VAL 3)


3. Daten und Datentypen

• Grundlegendes

• Die Sprache VAL3

• Einfache Datentypen

• Typ bool

• Typ num

• Typ string

• Typ dio

• Typ aio

• Typ sio

• Strukturierte Datentypen (folgen in Teil 5)


3.1 Grundlegendes

Information und Daten

• Was ist Information?

Information ist die abstrakte Bedeutung (Semantik) einer physikalischen

Nachricht.

• Was sind Daten?

Daten sind die physikalische Repräsentation von Information (z.B. im

Binärsystem des Computers).

• Was ist ein Computerprogramm?

Es verarbeitet Daten und damit Information (vgl. Datenverarbeitung).

• Wie kommen Daten in ein Programm?

Ihre physikalische Repräsentation wird als Variable bezeichnet.


3.1 Grundlegendes

Einteilung der Datentypen

• Elementare Datentypen

sind Binärdaten die in der HW eines Computers direkt realisiert sind: int, byte, short, long,

float, double, num,

char,

bool

• Strukturierte Typen

sind aus elementaren Datentypen zusammengesetzt und haben einen

Bauplan (struct ) string, frame, point, config, joint, …

auch

Arrays, Collections, benutzerdefinierte Strukturen


3.1 Grundlegendes

Datentyp und Wertebereiche

Alg.

Datentypen

Struct

Typen

Elementare

Typen

Zahlen

Zeichen

Logik

Ganze

Zahlen

Fließkomma

Zahlen num 14 Dezimalstellen Genauigkeit

bool true / false

char 8 bit ASCII, 0 - 255

int 32 bit, -2147483648 …+2147483647

short 16 bit, -32768 … +32767

byte 8 bit, -128 … +127

string Zeichenkette beliebiger Länge

Array

Struct point Lage und Orientierung im Raum

joint Roboterstellung


3.1 Grundlegendes

Wertebereiche, Konstante und Operatoren

Der Datentyp definiert:

• Wertebereiche ergeben sich aus der Repräsentation (Binärcodierung) z.B.: int als 32 bit signed integer, -4.294.967.296 … 4.294.967.295

• Konstante Werte sind sog. Literale (Schreibweisen) von festen Werten im Programm, z.B.: 1234 für einen int Typ “Achtung“ für einen string

• Operatoren und Funktionen sind die Operationen mit denen man Daten verarbeiten kann: num x

string name

x = x + 5

name = left(“Achtung“, 4)


3.1 Grundlegendes

Variable = benannte Daten in einem Programm

• Datentyp

legt Wertebereich und Operatoren/Funktionen fest

• Aktueller Wert

elementare aktuelle Repräsentation der Daten, jederzeit veränderbar

• Name

eindeutiger Bezeichner

• Initialisierung

Anfangs-/Startwert

• Gültigkeitsbereich

Sichtbarkeit in verschiedenen Teilen eines Programms

• Lebensdauer

während der Ausführung eines Programms

• Speicherplatz

physikalische Repräsentation (irrelevant für den Anwender)


3.1 Grundlegendes

Ausdrücke

• Beispiel für einen Ausdruck: bool x

num a, b

x = -a + 2 * cos(b-45) > 0

• Ausdruck beinhaltet: Variable, Konstanten, Klammern

Operatoren, Funktionsaufrufe

• Wichtig: Datentypen der Operanden

Rangfolge der Operatoren

Operanden eines Operators

Abarbeitung links/rechts

Nötige Klammerung

Parameter einer Funktion

Ergebnistyp einer Funktion

cos(.) Wert der

Variablen a

Wert der

Variablen b

Konstanter

Wert 2

Konstanter

Wert 0

Variable x

*

+

>

=

-VZ

Konstanter

Wert 2

-


3.2 Die Sprache VAL3

Einführung

• VAL3 ist eine höhere Programmiersprache für die Steuerung von Stäubli-Robotern zur Ausführung industrieller Handhabungs- und Montageaufgaben.

• VAL3 besitzt alle wichtigen Funktionen von gängigen Echtzeit-Programmiersprachen und zusätzlich die speziellen Steuerungsfunktionen für Industrieroboter, z.B.:

• Bewegungssteuerung des Roboters

• Funktionen zur Erstellung geometrischer Modelle

• Zugriff auf die Ein- und Ausgänge von programmierbaren Steuerungen

[Referenzanleitung VAL3, Version 5.2, Stäubli]



Die Elemente der Sprache VAL3

• Die Sprache VAL3 enthält folgende Elemente:

• Applikationen

• Programme (Unterprogramme)

• Bibliotheken

• Datentypen

• Konstanten

• Variablen (globale, lokale und Parameter)

• Tasks



Applikation

• Eine VAL3-Applikation ist ein eigenständiges, ausführbares Programm zur

Steuerung eines Roboters mit einer CS8-Steuerung.

• Eine VAL3-Applikation besteht aus folgenden Elementen:

• einer Menge von Unterprogrammen: den auszuführenden VAL3-

Anweisungen,

• einer Menge von globalen Variablen: den Daten der Applikation

• einer Menge von Bibliotheken: von der Applikation benutzte externe

Anweisungen und Daten

• Während ihrer Ausführung enthält eine Applikation außerdem:

• eine Menge von Tasks: die zu diesem Zeitpunkt nebenläufig Programme

ausführen



Programm (Unterprogramm)

• Ein Programm enthält eine Reihe von VAL3-Anweisungen, die auszuführen sind.

• Es besteht aus folgenden Elementen:

• einer Sequenz von Anweisungen: den auszuführenden VAL3-Anweisungen,

• einer Menge von lokalen Variablen: den programminternen Daten,

• einer Menge von Parametern: den Daten, die dem Programm beim Aufrufen geliefert werden (Input / Output).

• Programme dienen zur Zusammenfassung von Anweisungssequenzen, um sie an verschiedenen Stellen in einer Applikation verwenden zu können. Neben dem geringeren Programmierungsaufwand werden die Applikationen dadurch übersichtlicher, was die Programmierung und Wartung erleichtert und die Lesbarkeit verbessert.

• Die Anzahl der Programmanweisungen ist nur durch den im System verfügbaren Speicherplatz begrenzt.

• Die Anzahl der lokalen Variablen und Parameter ist nur durch den Ausführungsspeicher der Applikation begrenzt.



Programm start() und stop()

• Programm start()

• Um die VAL3-Applikation zu starten, wird das Programm start() aufgerufen. Es kann keine Parameter besitzen.

• In diesem Programm befinden sich alle zum Start der Applikation erforderlichen Vorgänge: Initialisierung der globalen

• Das start()-Programm kann, wie jedes andere Programm, in einem anderen Programm aufgerufen werden (Anweisung call).

• Programm stop()

• Das Programm stop() wird am Ende der Ausführung der VAL3-Applikation aufgerufen. Es kann keine Parameter besitzen.

• In diesem Programm finden sich im Allgemeinen alle zum korrekten Beenden der Applikation erforderlichen Vorgänge:

• Das stop()-Programm kann, wie jedes andere Programm, in einem anderen Programm aufgerufen werden (Anweisung call): Das Aufrufen des stop()-Programms führt nicht zum sofortigen Abbruch der Applikation.



Einfache Datentypen in VAL3

Die Sprache VAL3 unterstützt folgende einfache Typen:

• Typ bool: für boolesche Werte (true/false)

• Typ num: für numerische Werte (float mit 14 Stellen Genauigkeit)

• Typ string: für Zeichenketten beliebiger Länge

• Typ dio: für digitale Ein-/Ausgänge einer SPS

• Typ aio: für numerische Werte von Ein-/Ausgängen (analog oder digital)

• Typ sio: für Ein-/Ausgänge serieller Verbindungen und Ethernet-Socket

(Kommunikation)



Strukturierte Datentypen in VAL3

Ein strukturierter Typ enthält mehrere elementare oder auch andere

strukturierte Datentypen, die so genannten Datenfelder.

• Strukturierte Datenfelder können mit einem Namen einzeln angesprochen

werden

Die Sprache VAL3 unterstützt folgende strukturierte Typen:

• Typ trsf: für kartesische Koordinatentransformationen

• Typ frame: für das kartesische Koordinatensystem

• Typ tool: für die am Roboter montierten Tools

• Typ point: für die kartesischen Toolpositionen

• Typ joint: für die Winkelpositionen der Robotergelenke

• Typ config: für die Roboterkonfigurationen

• Typ mdesc: für die Bewegungsparameter des Roboters

• Benutzerdefinierte Typen



Konstante in VAL3

Eine Konstante ist ein Datenelement, das direkt und ohne vorherige

Deklaration in einem VAL3-Programm festgelegt (unveränderbar) ist.

Der Typ einer Konstante ist implizit durch das System vorgegeben.

• Konstanten einfachen Typs z.B.:

bool bBool

num nPi

string sString

bBool = true

nPi = 3.141592653

sString = "Dies ist eine konstante Zeichenkette"



Konstante in VAL3

• Konstanten strukturierten Typs Der Wert einer Konstante strukturierten Typs ist durch die aufeinanderfolgenden Werte ihrer Felder festgelegt. Die Reihenfolge ist durch die Definition des Typs vorgegeben.

• Zum Beispiel procedure dummy(trsf t, dio d)

point p

p = {{100, -50, 200, 0, 0, 0}, {sfree, efree, wfree}}

call dummy({a+b, 2* c, 120, limit(c, 0, 90), 0, 0}, io:Ventil1)

• Konstantentabelle/Array joint j[5 ]

j[0] = {0, 0, 0, 0, 0, 0}

j[1] = {90, 0, 90, 0, 0, 0}

j[2] = {-90, 0, 90, 0, 0, 0}

j[3] = {90, 0, 0, -90, 0, 0}

j[4] = {-90, 0, 0, -90, 0, 0}



Variablen

Eine Variable ist ein Datenelement in einem Programm, das durch seinen Namen

(Bezeichner) identifiziert wird.

Eine Variable ist definiert durch:

• ihren Bezeichner: eine Zeichenkette

• ihren Typ: einen der oben beschriebenen VAL3-Typen

• ihre Größe: z.B. die Anzahl der Datenelemente in einem Array

• ihren Gültigkeitsbereich: das (die) zur Verwendung dieser Variablen

berechtigte(n) Programm(e)

• Der Name einer Variablen ist eine Zeichenkette mit 1 bis 12 Zeichen von

"a..zA..Z0..9_". Er darf nicht mit einer Ziffer beginnen.

• Alle Variablen können als Array (Tabelle) verwendet werden. Einfache Variablen haben die Größe 1. Z.B.: a[0], a[1], a[2]

• Die Größe einer Variablen kann mittels der Anweisung size()in Erfahrung

gebracht werden.



Gültigkeitsbereich einer Variablen

Eine Variable kann folgende Gültigkeitsbereiche haben:

• global: Diese Variable kann von allen Programmen verwendet werden

• lokal: Diese Variable kann nur in dem Programm verwendet werden, in dem sie

deklariert wurde (Parameter, lokale Variable)

• Haben eine globale und eine lokale Variable den gleichen Namen, wird das

Programm, in dem die lokale Variable deklariert ist, die lokale Variable verwenden

und nicht auf die globale Variable zugreifen.

• Die Parameter eines Programms sind lokale Variablen, die nur in dem Programm,

in dem sie deklariert wurden, verwendet werden können. Jedoch erhalten sie ihre

Initialisierung (Startwerte) an der Stelle, an der das Programm aufgerufen wird (call).



Zugriff auf den Wert einer Variablen

• Array (Tabelle)

Auf die Datenelemente einer Tabelle kann mit dem in Klammern gesetzten Index

zugegriffen werden ‘p[5]’. Der Index muss einen Wert zwischen 0 und (Größe-1)

besitzen, sonst wird bei der Ausführung eine Fehlermeldung generiert.

Wenn kein Index spezifiziert wurde, wird der Index 0 verwendet: var[0] entspricht

var.

• Strukturierte Typen

Die einzelnen Felder von strukturierten Variablen sind mit einem ‘.’ gefolgt vom

Namen des Feldes zugänglich ‘pOrig.tsrf’.



Beispiele Variablen und Zugriff

num a // a ist eine Variable vom Typ num mit der Größe 1

num b[10] // b ist eine Variable vom Typ num mit der Größe 10

trsf t

point p

a = 0 // Initialisierung einer einfachen Variable

a[0] = 0 // Korrekt: entsprechend a = 0

b[0] = 0 // Initialisierung des ersten Datenelements der Tabelle b

b = 0 // Korrekt: entsprechend b[0] = 0

b[5] = 5 // Initialisierung des 6. Datenelements der Tabelle b

b[5.3] = 7 // Korrekt: entsprechend b[5] = 7

b[-1] = 0 // Fehler: Index kleiner 0

b[10] = 0 // Fehler: Index zu groß

t = p.trsf // Initialisierung von t

p.trsf.x = 100 // Fehler: x ist nicht direkt zugänglich

t.x = 100 // Initialisierung des Feldes x einer Variable trsf

p.trsf = t // Initialisierung des Feldes trsf eines point



Parameterübergabe „by value“ oder „by reference“

• "By value"-Parameter Bei einer "By Value"-Parameter-Übergabe erstellt das System eine lokale Variable und initialisiert diese

mit dem Wert der Variablen oder des Ausdrucks, der vom aufrufenden Programm geliefert wird (Kopie).

Die Variablen des aufrufenden Programms, die als By Value-Parameter verwendet werden, bleiben

unverändert, auch wenn das aufgerufene Programm den Wert des Parameters geändert hat.

Eine Datentabelle kann nicht "by value" übergeben werden.

• "By Reference"-Parameter Bei einer "By Reference"-Parameter-Übergabe arbeitet das Programm nicht mehr mit einer Kopie des

vom aufrufenden Programm übergebenen Datenelements, sondern mit dem Datenelement selbst, das nur

lokal umbenannt wurde.

Die Variablen des aufrufenden Programms, die als By Reference-Parameter verwendet werden, ändern

ihren Wert, wenn das aufgerufene Programm den Wert des Parameters ändert.

Alle Elemente einer "By Reference" übergebenen Tabelle können benutzt und geändert werden. Wird ein

Element einer Tabelle "By Reference" übergeben, so können dieses Element und alle ihm folgenden

Elemente benutzt und geändert werden.

Die Anweisung size() ermöglicht es, die effektive Größe eines Parameters in Erfahrung zu bringen.

Wenn eine Konstante oder ein Ausdruck "By reference" übergeben wurde, hat eine Zuweisung des

entsprechenden Parameters keinen Effekt: der Parameter behält den Wert bei.

• Vgl. auch call


3.3 Einfache Typen

Typ bool

Variablen oder Konstanten des Typs bool können folgende Werte annehmen:

• true: wahr

• false: falsch

Die Initialisierung einer Variablen des Typs bool ist immer false.

Operatoren: (mit zunehmender Priorität) Variable bool a, Ausdruck bool b, bool c, Ergebnis <bool>

• a = b <bool> Zuweisung eines bool-Wertes, liefert den Wert als Ergebnis

• b or c <bool> Logisches „oder“

• b and c <bool> Logisches „und“

• b xor c <bool> Logisches „exklusiv oder“

• b != c <bool> Test auf Ungleichheit, entspricht xor

• b == c <bool> Test auf Gleichheit, entspricht !xor

• !b <bool> Logische Negation


3.3 Einfache Typen

Typ num

Der Typ num stellt einen numerischen Wert mit etwa 14 signifikanten Stellen dar.

• Numerische Berechnungen erfolgen daher mit einer durch die 14 Stellen

beschränkten Genauigkeit.

• Dies ist bei der Prüfung der Gleichheit zweier numerischer Werte zu

berücksichtigen: Deshalb muss in der Regel in einem Intervall geprüft werden: if abs(xIst - xSoll) < 0.1

Variablen des Typs num werden vorprogrammiert auf den Wert 0 initialisiert.

Konstanten numerischen Typs haben z.B. folgendes Format:

• 1

• 0.2

• -3.141592653

• 1.25E-9


3.3 Einfache Typen

Typ num, Operatoren

Operatoren: (mit zunehmender Priorität) Variable num a, Ausdruck num b, num c, Ergebnis <num>, <bool>

• a = b <num> Zuweisung eines num-Wertes, liefert den Wert als Ergebnis

• b != c <bool> Test auf Ungleichheit, exakt auf ca. 14 signifikanten Stellen

• b == c <bool> Test auf Gleichheit, exakt

• b >= c <bool> Test auf größer oder gleich

• b > c <bool> Test auf größer

• b <= c <bool> Test auf kleiner oder gleich

• b < c <bool> Test auf kleiner

• b – c <num> Rechenoperation Subtraktion

• b + c <num> Rechenoperation Addition

• b % c <num> Rechenoperation Modulo, Rest der Ganzzahldivision b : c

• b / c <num> Rechenoperation Division

• b * c <num> Rechenoperation Multiplikation

• -b <num> Rechenoperation Negation (Vorzeichenumkehr)


3.3 Einfache Typen

Typ num, Funktionen (1)

<Ergebnis-Typ> <Funktion-Name>(<Parameter-Typ> <Parameter-Name>[, …])

• num sin(num Winkel) Trigonometrische Funktion Sinus, Winkel in Grad °

• num asin(num Wert) Inverse Sinus-Funktion, -1 <= Wert <= 1

• num cos(num Winkel) Trigonometrische Funktion Cosinus, Winkel in Grad °

• num acos(num Wert) Inverse Cosinus-Funktion, -1 <= Wert <= 1

• num tan(num Winkel) Trigonometrische Funktion Tangens, Winkel in Grad °

• num atan(num Wert) Inverse Tangens-Funktion, -∞ <= Wert <= +∞

• num abs(num Wert) Absoluter Betrag von Wert

• num sqrt(num Wert) Quadratwurzel von Wert, Wert >= 0

• num exp(num Wert) e-Funktion eWert, Potenz der Eulerschen Zahl e = 2,7182…

• num ln(num Wert) Natürlicher Logarithmus, Wert >= 0

• num log(num Winkel) Zehnerlogarithmus, Wert >= 0

• num roundUp(num Wert) Aufrunden auf nächst größeren ganzzahligen Wert

• num roundDown(num Wert) Abrunden auf nächst kleineren ganzzahligen Wert

• num round(num Wert) Runden auf nächst gelegenen ganzzahligen Wert


3.3 Einfache Typen

Typ num, Funktionen (2)

• num min(num a, num b) Liefert den kleineren der beiden Werte a oder b

• num max(num a, num b) Liefert den größeren der beiden Werte a oder b

• num limit(num x, num min, num max)

Liefert den auf min bzw. max begrenzten Wert von x

• num sel(bool Bedingung, num WahrWert, num FalschWert)

Falls die Bedingung wahr ist wird der ‚WahrWert‘ geliefert; ansonsten der ‚FalschWert‘


3.3 Einfache Typen

Typ string

Variablen des Typs Zeichenkette (string) dienen zur Speicherung von Texten:

• Zeichenketten können eine maximale Länge von 128 Zeichen haben.

• Der Typ string akzeptiert editierbare Zeichen ohne Akzente (ASCII-Codes 32 bis 126) mit Ausnahme des Zeichens ".

• Variablen des Typs string werden auf den Wert "" initialisiert (Länge 0).

Konstante von Typ string:

• ““, “Geben sie bitte den Startwert an!“

Operatoren: (mit zunehmender Priorität) Variable string a, Ausdruck string b, string c, Ergebnis <bool>,

<string>

• a = b <string> Zuweisung eines strings, liefert den Wert als Ergebnis

• b != c <bool> Test auf Ungleichheit (Folge der Zeichen wird verglichen)

• b == c <bool> Test auf Gleichheit (Gleiche Länge, alle Zeichen sind gleich)

• b + c <string> Verkettung von string a und b, begrenzt auf 128 Zeichen


3.3 Einfache Typen

Typ string, Funktionen (1) Umwandlung


• string toString(string Format, num Wert)

wandelt einen numerischen Wert in einen string um;

Format hat die Form “<Größe>.<Nachkommastellen>“, z.B. “8.2“

• string toNum(string Text, num& Wert, bool& Erfolg)

wandelt den ersten Teilstring des Textes in einem numerischen Wert und

liefert den Rest des Textes als Zeichenkette zurück Erfolg zeigt an, ob eine numerische Stringrepräsentation gefunden wurde (true)

• string chr(num Code)

wandelt den numerischen ASCII-Code in einen String eines einzelnen Zeichens um

Gültige Codes = 32, 33, 35, 36, … 126 (nicht 34 = “)

• num asc(string Text, num Position)

gibt den numerischen ASCII-Code des Zeichens an der Position innerhalb der Kette Text 0 <= Position < Länge, sonst wird -1 geliefert


3.3 Einfache Typen

Typ string, Funktionen (2) Bearbeitung

• string right(string Text, num Größe)

• string left(string Text, num Größe)

• string mid(string Text, num Größe, num Position)

• string insert(string Text, string Einfügung, num Position)

• string delete(string Text, num Größe, num Position)

• num replace(string Kette, string Ersatz, num Größe, num Position)

• num find(string Text, string Suche)

• num len(string Text)

Liefert die Länge (Anzahl der Zeichen) des Strings

Zur detaillierten Beschreibung siehe: VAL3 Reference von Stäubli


3.3 Einfache Typen

Typ dio

Mit dem Typ dio kann eine VAL3-Variable einem digitalen Ein-/Ausgang des

Systems zugewiesen werden.

• Die im System deklarierten Ein-/Ausgänge können direkt in einer VAL3-Applikation

verwendet werden, ohne dass sie vorher in der Applikation als lokale oder globale Variable

deklariert werden müssen.

• Der Typ dio dient daher vor allem zum Parametrieren eines Programms, in dem Ein- oder

Ausgänge verwendet werden.

• Anweisungen, in denen eine Variable des Typs dio verwendet wird, die nicht einem im

System deklarierten Ein-/ Ausgang zugewiesen wurde, bewirken eine Fehlermeldung.

Operatoren: (mit zunehmender Priorität) Variable dio a, Ausdruck dio b oder bool b, Ergebnis <bool>

• a = b <bool> Setzen eines digitalen Ausgangs a auf Wert von b

• a != b <bool> Test auf Ungleichheit (boolscher Vergleich)

• a == b <bool> Test auf Gleichheit (boolscher Vergleich)


3.3 Einfache Typen

Typ dio, Funktionen

• void dioLink(dio& Variable, dio Quelle)

Verbindet eine Variable mit einem digitalen Ein-/Ausgang (Referenzierung)

• num dioGet(dio dTabelle)

interpretiert mehrere digitale Werte als Dualzahl und liefert den num. Wert

• num dioSet(dio dTabelle, num Wert)

setzt mehrere digitale Werte auf die entsprechenden Bits der Dualzahl von Wert



3.3 Einfache Typen

Typ aio

Der Typ aio ermöglicht es, eine VAL3 Variable einem numerischen Ein-/Ausgang

(digital oder analog) des Systems zuzuordnen.

• Die im System deklarierten Ein-/Ausgänge können direkt in einer VAL3-

Applikation verwendet werden, ohne dass sie vorher in der Applikation als lokale

oder globale Variable deklariert werden müssen.

• Der Typ aio dient daher vor allem zum Parametrieren eines Programms, in dem

Ein- oder Ausgänge verwendet werden.

• Anweisungen, in denen eine Variable des Typs aio verwendet wird, die nicht

einem im System deklarierten Ein-/Ausgang zugewiesen wurde, bewirken eine

Fehlermeldung.

• Eine Variable des Typs aio ist nicht von vornherein einem Ein-/Ausgang

zugewiesen und führt zu einer Fehlermeldung, wenn sie ohne Zuweisung

verwendet wird.

• Operatoren: Keine


3.3 Einfache Typen

Typ sio

Der Typ sio ermöglicht es, eine VAL3-Variable einem seriellen Ein-/Ausgang des Systems oder einer Verbindung per Ethernet-Socket zuzuordnen. Ein sio-Ein-/Ausgang ist gekennzeichnet durch:

• Im System definierte, dem Typ der Kommunikation eigene Parameter

• Ein Zeichenketten-Endzeichen, um die Verwendung des Typs string zu ermöglichen

• Eine Kommunikations-Wartefrist (Timeout)

• Die seriellen Ein-/Ausgänge des Systems sind ständig aktiviert. Die Verbindungen per Ethernet-Socket werden beim ersten Lese-/Schreibzugriff durch ein VAL3-Programm aktiviert. Bei Beendigung der VAL3-Anwendung, werden die Verbindungen per Ethernet-Socket automatisch deaktiviert.

• Die im System erklärten Ein-/Ausgänge sind in einer Applikation des Typs VAL3 direkt verwendbar, ohne dass sie in der Applikation als globale oder lokale Variable erklärt werden müssen. Der Typ sio dient daher vor allem zum Parametrieren eines Programms, in dem Ein- oder Ausgänge verwendet werden.

• Anweisungen, in denen eine Variable des Typs sio verwendet wird, die nicht einem im System deklarierten Ein-/Ausgang zugewiesen wurde, bewirken eine Fehlermeldung.

• Eine Variable des Typs sio ist nicht von vornherein einem Ein-/Ausgang zugewiesen und führt zu einer Fehlermeldung, wenn sie ohne Zuweisung verwendet wird.


3.3 Einfache Typen

Typ sio, Operatoren

Operatoren: (mit zunehmender Priorität) Variable sio s, Ausdruck string t oder num x, Ergebnis <string>, <num>

• s = t <string> Senden der Zeichen in t und Abschluss mit Ende Kennzeichen

• s = x <num> Senden eines Bytes (num x modulo 256)

• t = s <String> Lesen (Empfangen) eines Strings

• x = s <String> Lesen (Empfangen) eines Bytes


3.3 Einfache Typen

Typ sio, Funktionen

• void sioLink(sio& Variable, sio Quelle)

Verbindet eine Variable mit einem Zeichen-Stream (Referenzierung)

• num clearBuffer(sio Eingang)

leert den Empfangsbuffer und liefert die Anzahl der gelöschten Zeichen

• num sioGet(sio Eingang, num& ByteArray)

liest Byte-Daten vom Eingang in ein Array von numerischen Werten und liefert die Anzahl

der gelesenen Zeichen. Der Lesevorgang wird beendet, wenn das Array Bytes voll ist oder der Empfangsbuffer leer ist.

• num sioSet(sio Ausgang, num& ByteArray)

Sendet Bytes aus dem angegebenen Array an den Ausgang und teilt die Anzahl der

geschriebenen Bytes mit. Die digitalen Byte Werte werden vor der Übertragung in ganze

Zahlen zwischen 0 und 255 umgewandelt.



Teil 4: Kontrollstrukturen

Bedingte Verzweigung, Schleifen, Auswahl (am Beispiel von Stäubli‘s VAL 3)


4. Kontrollstrukturen

• 4.1 Notation des Programmablaufs

• 4.2 Bedingte Verzweigung

• 4.3 Auswahlanweisung

• 4.4 Wiederholungsanweisung while

• 4.5 Wiederholungsanweisung for

• 4.6 Wiederholungsanweisung until

• 4.7 Benutzerschnittstelle


4.1 Notation

Programmablaufbeschreibung - Flussdiagramm

Programmschritt: Anweisungen, Prozess, Verarbeitung

Ein- / Ausgabe: Externe Daten

Verzweigung: Binär oder mehrfach

Grenzstelle: Start, Ende, Funktionskopf, Label

Vordefinierter Programmschritt: Unterprogramm-Aufruf, Funktion, Teilprozeß

Flussrichtung:


4.1 Notation

Programmablaufbeschreibung - Struktogramm

Eingabe: n

summe = 0

Programmschritt: Anweisungen, Prozess, Verarbeitung

Verzweigung: Hier Binär

Wiederholungsanweisung: Hier while bzw. for Struktur

ja nein

n > 0

/ n = -n

for i = 1 … n

summe = summe + i

Ausgabe: summe


4.2 Bedingte Anweisung

if – else

if <bool Bedingung>

<Wahr

Anweisungen>

else

<Falsch

Anweisungen>

endif

Verzweigung

Bedingung

Wahr-

Anweisungen

Falsch-

Anweisungen

weiter

wahr falsch



Aufbau if – else

If-Anweisung:

if <bool Bedingung > Wahr-Anweisung else Falsch-Anweisung

if <bool Bedingung > Wahr-Anweisung

• Bedingung : Boolscher Ausdruck; ergibt sich true wird die Anweisung

nach if ausgeführt. Andernfalls wird – falls vorhanden – die Anweisung

nach else ausgeführt.

• Falsch-Anweisung: else Anweisung kann fehlen

• Wenn mehrere if-Anweisungen geschachtelt sind, gehört ein else immer

zum unmittelbar voranstehenden if



Beispiel (1)

// Quadratische Gleichung

num a, b, c

string s

a = …

if b*b – 4*a*c < 0

s = “keine Loesung“

else

s = “zwei Loesungen“

endif

Quadratische Gleichung

dis < 0

Ausgabe:

keine Lsg.

Ausgabe:

zwei Lsg.

Ende

ja nein

Eingabe der Koeff.:

a, b, c

Diskriminante

dis = b2 – 4ac



Beispiel (2)

// Quadratische Gleichung

num a, b, c

string s

a = …

if b*b – 4*a*c < 0

s = “keine Loesung“

else

s = “zwei Loesungen“

endif

Eingabe der Koeffizienten:

a, b, c

ja nein

dis < 0

Ausgabe:

keine Lsg.

Ausgabe:

zwei Lsg.

Lösung der quadratischen Gl.

dis = b2 – 4ac



Mehrfach-Verzweigung (1)

// Konfektionsgröße num Groesse string Kennz

if Groesse <= 36

Kennz = “S“

else if Groesse <= 40

Kennz = “M“

else

if Groesse <= 42

Kennz = “L“;

else

Kennz = “XL“;

endif

endif

endif put("Groesse: " + Kennz);

Konfektionsgröße

Größe <= 36

Ausgabe: Kennz

Ende

ja

Eingabe: Größe

Kennz = “S“

Größe <= 40 ja

Kennz = “M“

Größe <= 42 ja

Kennz = “L“

Kennz = “XL“



Mehrfach-Verzweigung (2)

// Konfektionsgröße num Groesse string Kennz

if Groesse <= 36

Kennz = “S“

else if Groesse <= 40

Kennz = “M“

else

if Groesse <= 42

Kennz = “L“;

else

Kennz = “XL“;

endif

endif

endif put("Groesse: " + Kennz);

Eingabe des Wertes:

Größe

ja nein

Größe ≤ 36

"S"

Konfektionsgröße:

Ausgabe des Kennzeichens:

"M" "L" "XL"

ja nein

Größe ≤ 40

ja nein

Größe ≤ 42



Verwendung logischer Operatoren

// Eingabeüberprüfung 1 ≤ x ≤ 6

num x

get(x)

if x < 1 or x > 6

put(“error“)

else

put(x)

endif

...

Prüfe Eingabe

x < 1 or x > 6

“Error“

ja

Eingabe: x

nein

Ausg.: x


4.3 Auswahlanweisung

Mehrfach Auswahl - Prinzip

// Auswahl mit Integer num Wahl get(Wahl) switch Wahl case 1 // Anweisungsblock für 1 … break case 2, 3 // Anweisungsblock für 2,3 … break default: // Anweisungsblock sonst … break endSwitch

Auswahlanweisung

Wahl

weiter

1

Wahl (Integer)

Anweisung 1

Anw. 2,3

Anw. sonst

2,3

sonst

Ganzzahl

Ausdruck

switch-

Block

switch-

Marke



Aufbau der switch-Anweisung

Switch-Anweisung: switch Ausdruck Switch-Block endSwitch

• Typ des Ausdrucks: num, wird auf ganze Zahl gerundet

• Die switch-Marke case … muss konstant sein und wird ebenfalls gerundet

• Eine switch-Marke darf nur einmalig innerhalb eines switch-Blocks

verwendet werden

• Innerhalb eines switch-Blocks darf nur einmal die Marke default

verwendet werden

• break wird am Ende jeden Abschnitts benötigt, damit die Ausführung nicht

an der nächsten switch-Marke fortgesetzt wird



Beispiel Zähler

// Auswahl Menue: Zähler num x num n get(x) n = 0 switch x case 1 n = n+1 break case 2 n = n-1 break; case 3 stop() break default put(“Error“) break endSwitch

Auswahlanweisung

x

weiter

1

Eingabe: x

n++

n--

“error“

2

sonst

stop() 3

n = 0



Beispiel Himmelsrichtung (1)

// Umsetzung Kurs -> N,NE,E,SE,…

num kurs

string text

switch ((kurs+22.5)/45) % 8

case 0 text = “N“ break

case 1 text = “NE“ break

case 2 text = “E“ break

case 3 text = “SE“ break

case 4 text = “S“ break

case 5 text = “SW“ break

case 6 text = “W“ break

case 7 text = “NW“ break

default

text = “Error“

break

endSwitch

put(“Kurs: “ + text)

Kurs Umwandlung

[int]

(kurs+22,5)/45

Ausgabe: text

0

Eingabe: kurs

text = “N“

text = “NE“

text = “Error“

1

sonst

text = “E“ 2

…

Ende



Beispiel Himmelsrichtung (2)

// Kurs in ° -> N,NE,E,SE,…

num kurs

string text

switch ((kurs+22.5)/45) % 8

case 0 text = “N“ break

case 1 text = “NE“ break

case 2 text = “E“ break

case 3 text = “SE“ break

case 4 text = “S“ break

case 5 text = “SW“ break

case 6 text = “W“ break

case 7 text = “NW“ break

default

text = “Error“

break

endSwitch

put(“Kurs: “ + text)

Eingabe des Kurses:

kurs

wähle für s =

txt=

"N"

Kursumwandlung:

Ausgabe des Kurses: txt

s = [(kurs+22,5)/45]int mod 8

0

txt=

"NE"

txt=

"E"

txt=

"SE"

txt=

"S"

txt=

"SW"

txt=

"W"

txt=

"NW"

error

1 2 3 4 5 6 7 sonst


4.4 Wiederholungsanweisung - while

While-Schleife, Prinzip

Prinzip der while Schleife:

• Wiederhole solange die

Bedingung wahr ist;

• auch keinmal.

while <bool Bedingung>

// zu wiederholender

// Anweisungsblock

…

endWhile

// weiter

while Schleife

Bedingung

wahr

Wiederholungs-

Anweisungsblock

falsch

weiter

boolscher

Ausdruck

Wiederholungs-

Anweisung

Fortführung

nach Ende



Aufbau der while-Anweisung

While-Anweisung:

while bool-Ausdruck

Anweisung(en) endWhile

• bool-Ausdruck: Boolscher Ausdruck; die Anweisung(en) werden solange wiederholt, solange dieser Ausdruck true ergibt;

auch keinmal ist möglich

• Anweisung(en): Einzelne Anweisung oder Anweisungsblock



Beispiel: Blinken (1)

// Blinken eines Signals solange der

// Roboter in Bewegung ist

dio dLampe

dLampe = false

while !isSettled()

dLampe = !dLampe

delay(0.5);

endWhile

dLampe = false

// Ende

Flash

!isSettled() falsch

weiter

Lampe = off

Lampe=!Lampe

delay(0.5)

Lampe = off



Beispiel: Blinken (1)

// Blinken eines Signals solange der

// Roboter in Bewegung ist

dio dLampe

dLampe = false

while !isSettled()

dLampe = !dLampe

delay(0.5);

endWhile

dLampe = false

// Ende

Digitaler Ausgang: Lampe

while not isSettled()

// wiederhole

Lampe = off

Blinken einer Signallampe

Lampe = off

Lampe = not Lampe

delay(0.5)


4.5 Wiederholungsanweisung - for

For-Schleife, Prinzip

for-Schleife

Solange

i <= 20

Wiederholungsblock

falsch

weiter

Initialisierung:

i = 0

Inkrement:

i = i + Step

Prinzip einer for-Schleife

z.B.:

– starte bei i = 0, solange i <= 20

– erhöhe i um 5 nach jedem

Durchlauf

num i

for i = 0 to 20 step 5


// Anweisungsblock

…

endFor

// weiter



Aufbau der for-Anweisung

For-Anweisung:

for Variable = Startwert to Endwert step Schritt opt )

Anweisung(en) endFor

• Variable : num Variable, wird auch Schleifenzähler genannt

• Startwert : num Ausdruck; die Variable wird mit dem Startwert initialisiert

• Endwert : num Ausdruck; die Anweisung(en) werden solange wiederholt,

solange Variable <= Endwert bei Schritt > 0 oder

solange Variable >= Endwert bei Schritt < 0

• optional Schritt : zur Fortschreibung (Iteration) der Zählvariablen (durch

Komma getrennt).

• Anweisung: Einzelne Anweisung (ohne { }) oder Anweisungsblock

in { …}



Beispiele für Zählungen

num i

• for i = 0 to 9 // Zählen vorwärts i = 0, 1 … 9

• for i = 1 to 10 step 1 // Zählen vorwärts i = 1, 2 … 10

• for i = 9 to 0 step -1 // Zählen rückwärts i = 9, 8, … 0

• for i = 10 to 0 step -1 // Zählen rückwärts i = 10, 9, … 1

• for i = 5 to 13 // Zählen vorwärts i = 5, 6, … 13

• for i = 0 to N - 1 // N-mal ausführen

• for i = N to 1 step -1 // N-mal ausführen

• for i = 2 to 64 step 2 // gerade Zahlen Zählung

• for i = -1.0 to 1.0 step 0.1 // i = -1, -0.9, … 1.0



Beispiel Achsbewegung

// Drehung der Achse 1 in 10° Schritten

num i

joint Dest

Dest = {0,0,0,0,0,0}

for i = 90 to -90 step -10

Dest.j1 = i

movej(Dest, flange, mNomSpeed)

waitEndMove()

endFor

// Ende

Achsbewegung

i >= -90

i = i -10

nein

Ende

movej(Dest, …

Dest.j1 = i

i = 90, Dest = …



Beispiel Summe (1)

// Summe der Zahlen von 1 … N

num n

num i

num sum

get(n)

sum = 0

for i=1 to n

sum = sum + i

endFor

put(sum)

// Ende

Summe 1…N

i <= N

i = i + 1

nein

Ende

Eingabe: N

sum = sum + i

i = 1, sum = 0

Ausgabe: sum

N

i

isum1



Beispiel Summe (2)

// Summe der Zahlen von 1 … N

num n

num i

num sum

get(n)

sum = 0

for i=1 to n

sum = sum + i

endFor

put(sum)

// Ende

N

i

isum1

Eingabe der ganzen Zahl: N

for i = 1, 2, … N

sum = sum + i

Ausgabe: sum

Summe der Zahlen von 1 … N

sum = 0



Beispiel Rückwärtszählen

// Summe der Zahlen von N … 1

num n

num i

num sum

get(n)

sum = 0

for i = n to 1 step -1

sum = sum + n

endFor

put(sum)

// Ende

Summe 1…N

N > 0

N = N - 1

nein

Ende

Eingabe: N

sum = sum + N

sum = 0

Ausgabe: sum


4.6 Wiederholungsanweisung - until

until-Schleife, Prinzip

Prinzip do-until Schleife:

• wiederhole,

breche ab wenn die

Bedingung wahr ist

• immer mindestens einmal

do


// Anweisungsblock

…

until <bool Bedingung>;

// weiter

do-while Schleife

Bedingung

wahr

Wiederholungs-

Anweisungsblock

falsch

weiter boolscher

Ausdruck

Wiederholungs-

Anweisung



until-Schleife, Prinzip

Do-Until-Anweisung:

do

Anweisung(en) until bool-Ausdruck

• bool-Ausdruck: Boolscher Ausdruck; die Anweisung(en) werden solange wiederholt, solange dieser Ausdruck false ist;

bei true wird abgebrochen

mindestens aber einmalig ausgeführt

• Anweisung: Einzelne Anweisung oder Anweisungsblock



Beispiel (1)

// Warten auf 'Enter' Tastendruck

num x

do

x = get();

until x == 270

// weiter

Tastendruck

x = 270 falsch

wahr

weiter

Eingabe.: x



Beispiel (1)

// Warten auf 'Enter' Tastendruck

num x

do

x = get();

until x == 270

// weiter

Tastencode: x

until x == 270

// wiederhole

… weitere Anweisungen

Eingabe Wiederholung:

Eingabe der Taste: x


4.7 Benutzerschnittstelle

• Die über die Benutzerschnittstelle VAL3 eingegebenen Anweisungen erlauben:

• die Anzeige von Meldungen auf dem Handbediengerät (MCP) für diese Applikation

• die Erfassung der Eingaben auf der Tastatur des MCP

• Das Bedienerdisplay hat 14 Zeilen mit je 40 Zeichen. Die letzte Zeile kann zur

Erstellung von Menüs mit zugeordneter Taste F1, F2, … verwendet werden.

• Eine weitere Zeile steht zur Anzeige eines Titels zur Verfügung.


4.7 Benutzerschnittstelle

Funktionen


• void userPage() Zeigt die Bedienerseite auf dem Display

• void userPage(bool fix) Wie oben, fixiert diese Anzeige bei fix = true

• void goto(num x, num y) Cursor Pos. in Spalte x (0…39), Zeile y (0…13)

• void cls() Löscht das Display und bewegt den Cursor (0,0)

• void put(num val) Gibt den numerischen Wert val aus

• void put(string text) Gibt den Text aus

• void putln(num val) Gibt den numerischen Wert val aus mit Zeilenumbruch

• void putln(string text) Gibt den Text aus mit Zeilenumbruch

• void title(string text) Gibt den Text im Titel des Displas aus

• num get(string& text) Liest eine Zeichenketteneingabe von der Tastatur

• num get(num& val) Liest eine Zahleneingabe von der Tastatur

• num get() Wartet und liefert den Code einer gedrückten Taste

• num getKey() Liefert die zuletzt gedrückte Taste ohne Warten

• bool isKeyPressed(num code) Prüft, ob die angegebene Taste gedrückt ist

• void popUpMsg(string text) Zeigt ein Popup-Fenster mit Text an


Teil 5: Modularisierung

Unterprogramme und Wiederverwendung

(am Beispiel von Stäubli‘s VAL 3)


5. Modularisierung

• 5.1 Konzepte der Programmgliederung

• 5.2 Unterprogramme in VAL3

• 5.3 Starten und Stoppen von Applikationen

• 5.4 Sonstiges zu Unterprogrammen


5.1 Konzepte der Programmgliederung

Anwendung / Applikation / Programm

• Eine VAL3-Applikation ist eine vollständige Ablaufsteuerung zur

Realisierung eines automatisierten Vorgangs mit einem Roboter.

• Eine VAL3-Applikation besteht aus folgenden Elementen:

• einer Menge von Unterprogrammen: den auszuführenden VAL3-

Anweisungen,

• einer Menge von globalen Variablen: den globalen Daten der Applikation

• einer Menge von Bibliotheken: von der Applikation benutzte externe

Anweisungen und Daten

• Die Gliederung der Gesamtaufgabe erfolgt in Form von

Unterprogrammen.

• Ein Unterprogramm oder auch Teilprogramm wird häufig als Programm

bezeichnet, was nicht mit der gesamten Applikation zu verwechseln ist.

• Eine Applikation ist eine Menge von Unterprogrammen.


5.1 Konzepte der Programmgliederung

Komponentenbildung

• Identifikation von in sich abgeschlossenen Teilaufgaben

• Top-Down Vorgehen, mehrstufig

• Minimierung der Schnittstellen zu anderen Programmteilen; d.h.:

• möglichst keine globalen Variable (! wichtig)

• keine versteckten Vereinbarungen (z.B. 1=stop, 2=cont., …)

• möglichst wenig Voraussetzungen, die zum Ablauf nötig sind

• Parametrieren anstatt von Variantenbildung

• Formulierung von klaren Vereinbarungen für den zu erbringenden Dienst in

Form eines Vertrags und Dokumentation

• Verbergen von unnötigen Details vom Aufrufer

• Programmteile müssen klein und überschaubar sein (kein Unterprogramm

länger als eine DIN A4 Seite Ausdruck)

• Komplexere Aufgaben werden durch Kombination von kleineren Programmteilen

realisiert


5.2 Unterprogramme in VAL3

Definitionen

• Definieren einen eigenständigen, benannten Anweisungsblock, der durch einen Aufruf (call) ausgeführt wird

• Sie haben einen eindeutigen Namen (innerhalb einer Applikation) und eine

definierte Liste an Aufruf-Parameter

• Sie müssen deklariert (vereinbart) und definiert (Implementiert) werden

• Beim Aufruf wird eine feste Anzahl von Werten als Argumente (Parameter)

übergeben; die Reihenfolge und die zugehörigen Datentypen werden in der

Deklaration festgelegt

• Sie dienen zur Definition von:

• wiederkehrenden und häufig benötigten Programmteilen

• Segmenten eines komplexen Bewegungsablaufs

• Kommunikation mit externen Steuerungen

• Alg. Teilaufgaben/Diensten innerhalb der Gesamtapplikation



Unterprogramme und Parameter

• An ein Unterprogramm können zur Ausführungszeit beliebig viele Werte als

Input-Parameter übergeben werden (Übergabe by Value).

• Ein Unterprogramm kann beliebig viele „Werte“ als Output-Parameter an

den Aufrufer zurückliefern (Übergabe by Reference !).

• Beispiel: pick (num Row, num Col, bool& Success)

Input-Parameter (by Value) Output-Parameter (by Reference &) Name



Unterprogramm Aufruf

• Beispiel: pick (num Row, num Col, bool& Success)

pick(Row, Col,

Success)

// Aufrufender Programmteil

bool Erfolg

call pick(2, 4, Erfolg)

if Erfolg

….

Service:

pick up Bauelement

vom Vorrat an Position (Row, Col) und

setze bei Erfolg die Variable Success auf ‘true’

Return

2, 4, Erfolg

Erfolg = true



call-Anweisung

• Funktion

call führt das aufgerufene Unterprogramm mit den angegebenen Parameter-

Werten aus.

• Beispiel: Bestückung mit Bauteilen aus einem Vorrat num i

num j

bool ok for i = 0 to 3

for j = 0 to 9

call pick (i, j, ok)

if ok

call place (i, j)

endIf

endFor

endFor



Definition eines Unterprogramms

• VAL3 Syntax zur Definition eines Unterprogramms:

programm printMenue(string Text)

begin

num i

for i = 0 to size(Text)-1

goto (0, 6*i)

put (Text[i])

endFor

end



return-Anweisung

• Funktion

Das laufende Unterprogramm wird sofort verlassen:

• Wenn das Programm durch einen call aufgerufen worden war, wird die

Programmausführung im aufrufenden Programm nach dem call fortgesetzt.

• Andernfalls (z. B. wenn das Unterprogramm das Programm start() oder der Startpunkt für eine Task ist) wird die laufende Task beendet.



Parameterübergabe Problematik

• Aufgabe: Schreiben sie ein Unterprogramm welches den Mittelwert

2er beliebiger Zahlen bestimmt

// Deklaration global

num ZahlA

num ZahlB

num Ergebnis

programm start()

begin

ZahlA = 3

ZahlB = 7

call avg()

put(“Avg: “)

putln(Ergebnis)

end

programm avg()

begin

Ergebnis = (ZahlA+ZahlB)/2

end

• Nachteile:

Die Variablennamen sind fest vergeben.

Nebenläufiger Zugriff von verschiedenen

Tasks kann zu erheblichen Problemen

führen.

• Wunsch:

Die beiden Zahlen existieren nur für die

Dauer der Berechnung.

Ihre Werte werden als Kopie an das

Unterprogramm übergeben (by value).

Beim Aufruf des Unterprogramms wird

festgelegt, wohin das Ergebnis zu schreiben

ist (by reference).



Parameterübergabe „by value“

Beim Aufruf des Unterprogramms avg()

• wird neuer lokaler Speicherplatz für die Parameter ZahlA und ZahlB angelegt

• den Parametern ZahlA wird 3 und ZahlB 7 zugewiesen

// Deklaration

num Ergebnis

programm start()

begin

call avg(3, 7)

put(“Avg: “)

putln(Ergebnis)

end

programm avg(num a, num b)

begin

Ergebnis = (a+b)/2

a = 0

end



Parameterübergabe „by reference“

Beim Aufruf des Unterprogramms avg()

• wird für den Reference Parameter kein neuer Speicherplatz angelegt

• die Rückgabe-Variable ‘result‘ verweist auf den selben Speicherplatz wie Ergebnis

// Deklaration lokal

num lErgebnis

programm start()

begin

call avg(3, 7, lErgebnis)

put(“Avg: “)

putln(lErgebnis)

end

programm avg(num a, num b, num& result)

begin

result = (a+b)/2

a = 0

end



„by value“ versus „by reference“

• by value z.B.: num Variable

• eine lokal verfügbare und in der Lebensdauer begrenzte Variable wird angelegt

• eine Änderung der Variablen im Unterprogramm hat keine Auswirkung im aufrufenden Programmteil

• by reference z.B.: num& Variable

• es existiert keine Kopie des Wertes; es wird lediglich ein neuer Name für die

selbe Repräsentation der Daten verwendet

• eine Änderung der Variablen im Unterprogramm ändert auch den Wert der Variablen im aufrufenden Programmteil



Vor-/Nachteile globaler Variablen

• Globale Variablen:

• sind in allen Programmen bekannt und können verwendet oder verändert werden

• RISOKO: der gleichzeitigen Nutzung

• werden für statische, bereichsübergreifende Daten, insbesondere der

geometrischen Definitionen, genutzt

• Lokale Variablen:

• sind nur im definierenden Unterprogramm bekannt

• müssen nicht global eindeutig benannt werden

• werden bei jedem Unterprogrammaufruf neu angelegt und müssen deshalb mit

einem Wert initialisiert werden

• werden beim Verlassen des Unterprogramms gelöscht, der aktuelle Wert ist

verloren

• werden für transiente (temporäre) Daten verwendet

• zum Datenaustausch werden Parameter verwendet


5.3 Starten/Stoppen von Applikationen

Programm start()

• start()

• Um eine VAL3-Applikation zu starten, wird das Programm start()

aufgerufen.

• Es kann keine Parameter besitzen.

• In diesem Programm befinden sich alle zum Start der Applikation

erforderlichen Vorgänge: Initialisierung der globalen Variablen, der Ein-

/Ausgänge, Starten der Tasks der Applikation....

• Die Applikation ist am Ende des start()-Programms noch nicht unbedingt

beendet, da noch andere Tasks dieser Applikation in der Ausführung sein

können.

• Das start()-Programm kann, wie jedes andere Programm, in einem

anderen Programm aufgerufen werden (Anweisung call start() ).


5.3 Starten/Stoppen von Applikationen

Programm start()

• stop()

• Das Programm stop() wird am Ende der Ausführung der VAL3-Applikation

aufgerufen.

• Es kann keine Parameter besitzen.

• In diesem Programm finden sich im Allgemeinen alle zum korrekten

Beenden der Applikation erforderlichen Vorgänge: Reinitialisierung der

Ein-/Ausgänge, Beenden der Tasks der Applikation in einer bestimmten

Reihenfolge ....

• Das stop()-Programm kann, wie jedes andere Programm, in einem

anderen Programm aufgerufen werden (Anweisung call stop() )

• Das Aufrufen des stop()-Programms führt nicht zum sofortigen Abbruch

der Applikation.


5.4 Eigenschaften von Unterprogrammen

Unterprogramme sind ‘reentrant‘

• Wiedereinsprung

• Unterprogramme erlauben den Wiedereinsprung (Reentrante

Programmierung), d.h. ein Unterprogramm kann sich selbst rekursiv

aufrufen (Anweisung call) oder von mehreren Tasks gleichzeitig

aufgerufen werden.

• Jeder Programmaufruf besitzt seine eigenen lokalen Variablen und

Parameter. Dadurch ist eine vollständige Entkopplung gegeben.

BMBF-Verbundprojekt OTH mind S. 145

Impressum

Autor: Prof. Dr.-Ing. Manfred Beham

Herausgegeben durch: Teilprojekt der OTH Amberg-Weiden aus dem Verbundprojekt

„OTH mind“ mit der OTH Regensburg des Bund-Länder-

Wettbewerbs „Aufstieg durch Bildung: offene Hochschulen“.

Kontakt: Hetzenrichter Weg 15, 92637 Weiden in der Oberpfalz

[email protected]

www.oth-aw.de/oth-mind

Copyright: Vervielfachung oder Nachdruck auch auszugsweise zur

Veröffentlichung durch Dritte nur mit ausdrücklicher Zustimmung

der Herausgeber.

Hinweis: Diese Publikation wurde im Rahmen des vom Bundesministerium

für Bildung und Forschung (BMBF) geförderten Bund-Länder-

Wettbewerbs „Aufstieg durch Bildung: offene Hochschulen“

erstellt. Die in dieser Publikation dargelegten Inhalte liegen in der

alleinigen Verantwortung der Autor/innen.

Grundlagen der Programmierung für Robotik - oth-aw.de · • Mathematik (Koordinatensysteme,...

Documents

Transcript of Grundlagen der Programmierung für Robotik - oth-aw.de · • Mathematik (Koordinatensysteme,...