Skript Robotik-Programmierung Und Handhabung Final

Robotik – Programmierung und Handhabung
Teil 1: Einführung in die Programmierung für Robotik

Teil 2: Robotik – Programmierung und Handhabung
(Begleitskript)
Michael Uschold
2019
OTH mind - BMBF Verbundprojekt
#aufstieggestalten
Dieses Material ist lizenziert unter einer Creative Commons Namensnennung – Weitergabe unter gleichen Bedingungen 4.0 International Lizenz (CC
BY-SA 4.0). Bei einer Weitergabe soll der Name des Urhebers wie folgt genannt werden: „Michael Uschold, OTH mind #aufstieggestalten, OTH Amberg-
Weiden“.
BMBF-Verbundprojekt OTH mind

Teil 1:
Einführung in die Programmierung für Robotik
BMBF-Verbundprojekt OTH mind S. 2

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

Eine Auswahl
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)
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.

Handhaben
Halten
aufnehmen, haften, spannen
Aufnehmen
annehmen, fassen (greifen), ergreifen (pflücken, schnappen)
Lage bestimmen
positionieren (einrichten), ordnen (orientieren)
Bewegen
zuführen (beladen, laden, eingeben, zubringen, einlegen)
weitergeben (transportieren, fördern, befördern, zuteilen, vereinzeln)
ausgeben (entladen, ausladen, auswerfen)
Ablegen
freigeben (loslassen, lösen), absetzen (abstellen, hinlegen)

Einteilung der Handhabungsgeräte nach VDI
Handhabungs-
geräte
Manuell gesteuert Programm gesteuert
Manipulator
Telemanipulator Fest programmiert Frei programmierbar
Einlegegerät Industrieroboter
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.

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

Hauptbestandteile eines Robotersystems
Der Grundaufbau eines Industrieroboters leitet sich aus der allgemeinen Aufgabe ab, einen Körper
im Raum durch Schieben und Drehen frei beweglich in eine andere Position bzw. Orientierung
gegenüber einem Bezugsystem zu bringen. Dazu müssen nachfolgende Komponenten koordiniert
zusammenwirken:
I Steuerung
II ausführende Einrichtung
III Arbeitsorgan
IV Peripherie
1 Roboterarm
2 Bewegungseinheit
3 Robotersteuerung
4 Anpasssteuerung
5 Handbedienpult
6 Drehtisch
Buch Industrieroboterpraxis - Stefan Hesse - Vieweg Verlag - Plauen, Juni 1998 - Seite 15

Teil 2: Kinematik (Einführung)
Koordinatensysteme, Transformation, Bewegungssteuerung

2. Kinematik
2.1 Kinematische Grundtype
2.2 Arbeits- und Kollisionsraum
2.3 Koordinaten und Transformation
2.4 Beschreibung einer Roboterstellung
2.5 Die kinematische Kette
2.6 Die kinematische Vorwärtstransformation
2.7 Die kinematische Rückwärtstransformation
2.8 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
Hesse, S.:
Industrieroboterpraxis.
Wiesbaden: Vieweg, 1998

2.1 Kinamatische Grundtypen
• Roboter bestehen aus einer Kombination von Drehgelenken (D) und/oder Schubgelenken (S),
welche in beliebiger Reihenfolge nacheinander angeordnet werden können.
• Jedes zusätzliche Gelenk schafft einen weiteren Freiheitsgrad für das System (bis auf zwei
hintereinander angeordnete Schubgelenke mit kleiner Ausrichtung).
Mögliche Kombinationen unter Verwendung von drei Drehgelenken:
Buch Industrieroboterpraxis - Stefan Hesse - Vieweg Verlag - Plauen, Juni 1998 - Seite 20

2.2 Arbeits- und Kollisionsaum
Je nach Art und Anzahl (mindestens 3) der

verwendeten Grundgelenke entsteht ein
Arbeitsraum für den Roboter.
a) DSS → Zylinder
b) DDS → Hohlkugelsegment
c) TTT → Kartesischer Raum (X, Y, Z)
d) DDD → Hohlkugel
e) DDT
Buch Industrieroboterpraxis - Stefan Hesse - Vieweg Verlag - Plauen, Juni 1998 -

Seite 22

Buch Industrieroboterpraxis - Stefan Hesse - Vieweg Verlag - Plauen, Juni 1998 - Seite 54/55

Bei der Auslegung einer

Roboterarbeitszelle ist nicht nur der zur
Verfügung stehende Arbeitsraum,
sondern auch der entstehende
Kollisionsraum zu berücksichtigen.
Durch konstruktive Maßnahmen (Bsp.:

Teleskoparm) kann der Kollisionsraum
auf ein Minimum reduziert werden.
B = Bewegungsraum
A = Arbeitsraum
K = Kollisionsraum
Buch Industrieroboterpraxis - Stefan Hesse - Vieweg Verlag - Plauen, Juni 1998

- Seite 23

Etablierte Gelenkombinationen
Drehgelenkstrukturen
Anwendungen:
- Montage
- Maschinenbeschickung
- Lackieren
- Verpacken
+ Vorteile
- Bewegungen ähnlich dem menschlichen Arm möglich
- Großer Arbeitsraum bei kleinem Kollisionsraum
- Kleine Stellfläche
- Nachteile
- Achsauflösung im Arbeitsraum nicht linear
- Lastausgleich bei waagerechten Drehachsen teilweise erforderlich

Drehgelenkstrukturen
Anwendungen:
- Montage
- Pick and Place
- Pelletieren
+ Vorteile
- Hohe Steifigkeit in Z-Achse
- Hohe Einpresskraft
- Kleine Stellfläche
- Nachteile
- Kleiner Arbeitsbereich
- Geringe Traglast
- Lastausgleich bei waagerechten Drehachsen teilweise erforderlich

Portalsysteme
Anwendungen:
- Maschinenbeschickung (v.a. sperrige Werkstücke)
- Entladen
- Stapeln
+ Vorteile
- Sehr großer Arbeitsraum möglich
- Bewegung der ersten 3 Achsen im kartesischen Raum (leicht vorstellbar)
- Achsauflösung im gesamten Arbeitsraum linear
- Nachteile
- Große Stellfläche
- Keine Veränderung der Orientierung möglich

Delta Systeme
Anwendungen:
- Pick and Place
- Verpacken
- Montage
- Materialhandhaben
+ Vorteile
- Hohe Presskräfte in Z-Richtung
- Sehr hohe Dynamik
- Nachteile
- Nur senkrechte Montagebewegung möglich
- Komplexer Programmieraufwand

Koordinatensysteme und Vektoren
Wir benutzen kartesische Koordinatensysteme mit drei senkrecht zueinander stehenden
Koordinatenachsen. Dabei gilt die Rechtsschraubenregel. In der Robotik werden zwei Arten von Vektoren
unterschieden:
 Freie Vektoren (Richtungsvektoren ) lassen sich im Raum beliebig verschieben und benötigen
keinen expliziten Ursprung des Koordinatensystems.
 Ortsvektoren sind relative Positionsangaben und gehen immer von einem Ursprung des
Koordinatensystems aus.
Beispiele:  vx 
 
1) Freier Vektor Geschwindigkeit: v  vy   vx vy vz T
v 
 z
 x
2) Ortsvektor p y ( x y z)
T
(benötigt Koordinatensystem)  
z

Homogene Koordinaten/Matrizen
Um jede Form der Vektor-/Koordinatentransformation einheintlich durch eine Matrix mal Vektor
Multiplikation 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.
 x
 
Homogener p
y T
Pkt ( x y z)  ( x y z 1 )
Ortsvektor: z
 
1
Alg. Transformation:  m11 m12 m13 tx 

 x  xm11  y m12  z m13  tx 
    
xm21  y m22  z m23  ty
p´ T p
 m21 m22 m23 ty
  y   
 m31 m32 m33 tz   z   xm31  y m32  z m33  tz 
    
 0 0 0 1  1  1 

Verschiebung (Translation)
y
y'
P
x'
1 0 0 x
 
Translation um Vektor ( x y z )
T
: Trl ( x y z) 
 0 1 0 y
0 0 1 z
 
0 0 0 1
Drehung um die z-Achse (Rotation)
y'
θZ
x'
z'
 cos(  ) sin (  ) 0 0
 
 sin (  ) cos(  ) 0 0
Rotation um die z-Achse um den Winkel ?: Rotz (  ) 
 0 0 1 0
 
 0 0 0 1

Drehung um die x-Achse oder y-Achse
1 0 0 0
 
Rotation um die x-Achse um den Winkel ?: Rotx(  ) 
 0 cos(  ) sin (  ) 0
 0 sin (  ) cos(  ) 0
 
0 0 0 1
 cos(  ) 0 sin (  ) 0 
 
Rotation um die y-Achse um den Winkel ?: Roty (  ) 
 0 1 0 0
 sin (  ) 0 cos(  ) 0 
 
 0 0 0 1

Koordinatentransformation Beispiele
Beispiel: Rotationvon 45° um die z-Achse
 0.7 0.7 0 0
 
p  Pkt ( 1 1 0) R  Rotz ( 45°) 
 0.7 0.7 0 0
 0 0 1 0
 
 0 0 0 1
T
p´  ( R p)  ( 0 1.4 0 1 ) R 1
Beispiel: Translation (0.5, 0.5, -0.5)

1 0 0 0.5 
 
p  Pkt ( 1 1 0) T  Trl ( 0.5 0.5 0.5 ) 
0 1 0 0.5 
0 0 1 0.5 
 
0 0 0 1 
T
p´  ( T p)  ( 1.5 1.5 0.5 1 ) T 1

Aufeinanderfolgende Transformationen (Verkettung)
Der Punkt P 1 wird durch T 1 in den Punkt P 2 und anschließend durch T 2 in den Punkt P 3 transformiert:
P2 T 1 P 1
P3 T 2 P 2 T 2 T 1 P 1
P3 T res P 1 T res T 2 T 1
T
Beispiel T  Trl ( 1 0 0) R  Rotz ( 45°) p  ( 1 1 0 1)
 0.7   0.7 0.7 0 0.7 

   
p´  R T p 
 2.1  R T 
 0.7 0.7 0 0.7 
 0   0 0 1 0 
   
 1   0 0 0 1 

Zweifach Gelenk-Knickarm
Beispiel: Zweifach Gelenk Knickarm
Armlängen: r1  10 r2  8  1  45°  2  90 ° P 2  Pkt ( 0 0 0)
Transformation:        
Tg  1  2  Rotz  1 Trl r1 0 0 Rotz  2 Trl r2 0 0  
i  0  2 P 1  Rotz   1 Trl  r1 0 0 P 2  
P 0  Tg  1  2 P 2
20
10
T
P 0  ( 12.7 1.4 0 1 )
 20  10 0 10 20
 10
 20
2.1.4 Beschreibung der Orientierung

Orientierung eines Körpers im Raum
Die Orientierung eines Körpers enthält drei Freiheitsgrade. Sie kann mathematisch auf verschiedene Arten
formuliert 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

Drehung eines Werkstückes - Merkregel
• Alle Koordinatensysteme eines Robotersystems verfügen über bis zu 6 Freiheitsgrade
• Translation in X-Richtung
• Translation in Y-Richtung
• Translation in Z-Richtung
Translation
• Rotation um X-Achse
• Rotation um Y-Achse
• Rotation um Z-Achse
Rotation
„Rechter Daumen“ Regel

• Transformation (trsf)
• Positionierung (x, y, z)
– 1. Verschiebung in X-Richtung
1.
– 2. Verschiebung in Y-Richtung
– 3. Verschiebung in Z-Richtung
– Bsp.: World als Bezugssystem
2.
3.

• Rotation (rx, ry, rz)
4.
– 4. Rotation um X-Achse
– 5. Rotation um Y‘-Achse
– 6. Rotation um Z‘‘-Achse
– Bsp.: World als Bezugssystem

5.
6.

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
P A der Punkt P in Koordinaten des Bezugssystems A.
P B der selbe Punkt P in Koordinaten des Bezugssystems B.
Wenn eine Transformation T A_B das Koordinatensystem K A in das System K B überführt, dann
transformiert T A_B auch Punkte von der Darstellung in B-Koordinaten in die Darstellung in
A-Koordinaten.
KB T A_BKA
PA T A_BP B
-1 wirkt genau 1
Die inverse Matrix T A_B umgekehrt: T A_B T B_A
KA T A_B  1 KB
PB  T A_B 1 P A

Ü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
Translation um (350; 0; 130).
– Das Effektorkoordinatensystem geht aus den Basiskoordinaten hervor durch eine Rotation um 135° um die y-Achse und eine
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 und Basiskoordinaten!

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
Abbildung 8. Die Armteile eines Roboters als kinematische Kette, in diesem

Beispiel 6 Armteile (N=6).
Die Armteile eines Roboters als kinematische Kette, in diesem Beispiel 6 Armteile (N=6)

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   x 
 
 2   y 
   z 

 3  

 .  x
   
 .   y
  z
 N  

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 Kette: K1 A1 K0

K2 A2 K1
...
KN AN KN1
Wenn man die K i schrittweise ersetzt kann man zusammenfassen:

KN AN  A2 A1 K0

Die Konventionen von Denavit und Hartenberg (2)
Für die Transformation von Punktkoordinaten gilt:
P0 A1 P 1
P1 A2 P 2
...
P N 1 AN P N
Woraus wieder schrittweise abgeleitet werden kann:

P0 A1 A2  AN P N
Das Matrizenprodukt A 1A2A3 ... AN ist also die Transformation vom

Koordinatensystem K N auf die raumfesten Fußkoordinaten K 0 und wird
hier als T 0_N bezeichnet.
T 0_N A1 A2  AN

Beispiel am 6 Gelenkarm Roboter
T
Gelenkwinkel:   ( 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)

 1 0 0.3 15.7 
 
Gesamt-Transf.: T 06  A1 A2 A3 A4 A5 A6 
 0.3 0 1 13.2 
 0 1 0 10.7 
 
 0 0 0 1 
 T
tp T 06  ( 15.7 13.2 10.7 )
 
 x T 06  90  °
 y  T 06   0  °
 z  T 06   165  °

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   1 
 
 y   2 
 z   
  
 3 
x  . 
   
 y  . 
z  
   N

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.

2.8 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
3.1 Grundlegendes
3.2 Die Sprache VAL3

3.3 Einfache Datentypen
– Typ bool
– Typ num
– Typ string
– Typ dio
– Typ aio
– Typ sio
3.4 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
joint
Roboterstellung
Struct point
Lage und Orientierung im Raum
Struct
Typen string
Array
Zeichenkette beliebiger Länge
byte
Alg. Ganze 8 bit, -128 … +127
Datentypen Zahlen short
Zahlen 16 bit, -32768 … +32767
int
Elementare Fließkomma 32 bit, -2147483648 …+2147483647
Typen Zahlen
num
14 Dezimalstellen Genauigkeit
Logik
bool
true / false
Zeichen char
8 bit ASCII, 0 - 255

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: Konstanter

Variable, Konstanten, Klammern Variable x + Wert 0
Operatoren, Funktionsaufrufe
• Wichtig: -VZ *
Datentypen der Operanden
Rangfolge der Operatoren Wert der Konstanter
cos(.)
Operanden eines Operators Variablen a Wert 2
Abarbeitung links/rechts
Nötige Klammerung
Parameter einer Funktion
-
Ergebnistyp einer Funktion
Wert der Konstanter
Variablen b Wert 2

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 // Die x-Komponente von Punkt p wird auf 100 gesetzt
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.

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
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!“

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.

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
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

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
Programmschritt:
Eingabe: n
Anweisungen, Prozess, Verarbeitung
summe = 0
n>0 Verzweigung:
hier Binär
ja nein
/ n = -n
for i = 1 … n Wiederholungsanweisung:
hier while bzw. for Struktur
summe = summe + i
Ausgabe: summe

4.2 Bedingte Anweisung
if – else
if <bool Bedingung> Verzweigung
<Wahr Anweisungen>
else wahr falsch

Bedingung
<Falsch Anweisungen>
endif
Wahr- Falsch-
Anweisungen Anweisungen
weiter

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 Quadratische Gleichung
num a, b, c
string s
a = … Eingabe der Koeff.:
a, b, c
if b*b – 4*a*c < 0

Diskriminante
dis = b2 – 4ac
s = “keine Loesung“
else
ja nein
dis < 0
s = “zwei Loesungen“
endif Ausgabe: Ausgabe:

keine Lsg. zwei Lsg.
Ende

Beispiel (2)
// Quadratische Gleichung Lösung der quadratischen Gl.
num a, b, c
string s
Eingabe der Koeffizienten:
a = …
a, b, c
if b*b – 4*a*c < 0 dis = b2 – 4ac
s = “keine Loesung“ dis < 0
ja nein
else
s = “zwei Loesungen“
Ausgabe: Ausgabe:
endif keine Lsg. zwei Lsg.

Mehrfach-Verzweigung (1)
// Konfektionsgröße Konfektionsgröße
num Groesse
string Kennz
Eingabe: Größe
if Groesse <= 36
Kennz = “S“ ja
else Größe <= 36 Kennz = “S“
if Groesse <= 40
Kennz = “M“ ja
else Größe <= 40 Kennz = “M“
if Groesse <= 42
Kennz = “L“; ja
Größe <= 42 Kennz = “L“
else
Kennz = “XL“;
endif Kennz = “XL“
endif
endif
Ausgabe: Kennz
put("Groesse: " + Kennz);
Ende

Mehrfach-Verzweigung (2)
// Konfektionsgröße Konfektionsgröße:
num Groesse
string Kennz
Eingabe des Wertes:
Größe
if Groesse <= 36
Kennz = “S“
Größe ≤ 36
else
if Groesse <= 40 ja nein
Kennz = “M“
else Größe ≤ 40
if Groesse <= 42 ja nein
Kennz = “L“;
else Größe ≤ 42
Kennz = “XL“; ja nein

endif
endif "S" "M" "L" "XL"
endif
Ausgabe des Kennzeichens:
put("Groesse: " + Kennz);

Verwendung logischer Operatoren
// Eingabeüberprüfung 1 ≤ x ≤ 6
num x
get(x)
Prüfe Eingabe
if x < 1 or x > 6
Eingabe: x
put(“error“)
ja
else
x < 1 or x > 6
put(x)
nein
endif “Error“
...
Ausg.: x

Mehrfach Auswahl - Prinzip
// Auswahl mit Integer
num Wahl Ganzzahl Auswahlanweisung
get(Wahl) Ausdruck
switch Wahl Wahl (Integer)
case 1
// Anweisungsblock für 1
… Wahl
break
case 2, 3 1
// Anweisungsblock für 2,3 Anweisung 1
…
break
switch- 2,3
default: Block Anw. 2,3
// Anweisungsblock sonst
…
break
sonst
endSwitch Anw. sonst
switch-
Marke weiter

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

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

Beispiel Himmelsrichtung (1)
// Umsetzung Kurs -> N,NE,E,SE,… Kurs Umwandlung
num kurs
string text
Eingabe: kurs
switch ((kurs+22.5)/45) % 8
[int]
case 0 text = “N“ break (kurs+22,5)/45
case 1 text = “NE“ break
case 2 text = “E“ break 0
case 3 text = “SE“ break text = “N“
case 4 text = “S“ break 1
case 5 text = “SW“ break text = “NE“
case 6 text = “W“ break 2
case 7 text = “NW“ break text = “E“
default
text = “Error“ …
break
sonst
endSwitch text = “Error“
put(“Kurs: “ + text)
Ausgabe: text
Ende

Beispiel Himmelsrichtung (2)
// Umsetzung Kurs -> N,NE,E,SE,…
num kurs
string text Kursumwandlung:
switch ((kurs+22.5)/45) % 8
Eingabe des Kurses:
kurs
case 0 text = “N“ break
case 1 text = “NE“ break
case 2 text = “E“ break
case 3 text = “SE“ break s = [(kurs+22,5)/45]int mod 8
case 4 text = “S“ break
case 5 text = “SW“ break
wähle für s =
case 6 text = “W“ break
case 7 text = “NW“ break
default
text = “Error“ 0 1 2 3 4 5 6 7 sonst
break
endSwitch
txt= txt= txt= txt= txt= txt= txt= txt= error
put(“Kurs: “ + text) "N" "NE" "E" "SE" "S" "SW" "W" "NW"
Ausgabe des Kurses: txt

4.4 Wiederholungsanweisung - while
While-Schleife, Prinzip
Prinzip der while Schleife:
• Wiederhole solange die Bedingung wahr ist; while Schleife
• auch keinmal.
boolscher falsch
while <bool Bedingung> Bedingung
Ausdruck
// zu wiederholender wahr
// Anweisungsblock
…
Wiederholungs-
Wiederholungs- Anweisungsblock
Anweisung
endWhile
// weiter
Fortführung weiter
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)
Flash
// Blinken eines Signals solange der
// Roboter in Bewegung ist
dio dLampe Lampe = off
dLampe = false
while !isSettled() falsch

!isSettled()
dLampe = !dLampe
delay(0.5);
endWhile Lampe=!Lampe
dLampe = false
// Ende delay(0.5)
Lampe = off
weiter

Beispiel: Blinken (1)
// Blinken eines Signals solange der
// Roboter in Bewegung ist
dio dLampe
dLampe = false Blinken einer Signallampe
while !isSettled() Digitaler Ausgang: Lampe
dLampe = !dLampe Lampe = off

delay(0.5);
while not isSettled()
endWhile
// wiederhole
dLampe = false
Lampe = not Lampe
// Ende
delay(0.5)
Lampe = off

4.5 Wiederholungsanweisung - for
For-Schleife, Prinzip
for-Schleife
Prinzip einer for-Schleife z.B.:
– starte bei i = 0, solange i <= 20
– erhöhe i um 5 nach jedem Durchlauf Initialisierung:
i=0
num i
falsch
for i = 0 to 20 step 5 Solange
i <= 20
// zu wiederholender
// Anweisungsblock
… Wiederholungsblock
endFor
Inkrement:
// weiter i = i + Step
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 Achsbewegung
num i
joint Dest
Dest = {0,0,0,0,0,0} i = 90, Dest = …
for i = 90 to -90 step -10

nein
Dest.j1 = i i >= -90
movej(Dest, flange, mNomSpeed)
waitEndMove()
Dest.j1 = i
endFor
movej(Dest, …
// Ende
i = i -10
Ende

Beispiel Summe (1) Summe 1…N
N Eingabe: N
sum   i
i 1
i = 1, sum = 0
// Summe der Zahlen von 1 … N nein

num n i <= N
num i
num sum
get(n)
sum = sum + i
sum = 0
for i=1 to n i=i+1
sum = sum + i
endFor
Ausgabe: sum
put(sum)
// Ende Ende

Beispiel Summe (1)
N
sum   i
Summe der Zahlen von 1 … N
i 1
Eingabe der ganzen Zahl: N
// Summe der Zahlen von 1 … N

num n sum = 0
num i
num sum for i = 1, 2, … N
get(n)
sum = 0
for i=1 to n sum = sum + i
sum = sum + i
endFor Ausgabe: sum
put(sum)
// Ende

Beispiel Rückwärtszählen Summe 1…N
// Summe der Zahlen von N … 1 Eingabe: N

num n
num i
num sum sum = 0
get(n)
sum = 0
nein
for i = n to 1 step -1 N>0
sum = sum + n
sum = sum + N
endFor
put(sum) N=N-1
// Ende
Ausgabe: sum
Ende

4.6 Wiederholungsanweisung - until
until-Schleife, Prinzip
Prinzip do-until Schleife:
– wiederhole,
breche ab wenn die Bedingung wahr ist do-while Schleife
– immer mindestens einmal
do Wiederholungs-
Anweisungsblock
// zu wiederholender
Wiederholungs-
// Anweisungsblock
Anweisung
…
falsch
until <bool Bedingung>; Bedingung

boolscher
// weiter wahr
Ausdruck
weiter

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
Tastendruck
num x
do
x = get();
Eingabe.: x
until x == 270
// weiter
x = 270
falsch
wahr
weiter

Beispiel (1)
// Warten auf 'Enter' Tastendruck
num x
Eingabe Wiederholung:
do
Tastencode: x
x = get();
until x == 270
// wiederhole
// weiter
Eingabe der Taste: x
until x == 270
… weitere Anweisungen

• 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.

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


5. Modularisierung
5.1 Konzepte der Programmgliederung
5.2 Unterprogramme in VAL3
5.3 Starten und Stoppen von Applikationen
5.4 Sonstiges zu Unterprogrammen

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.

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

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)
Name Input-Parameter Output-Parameter

(by Value) (by Reference &)

Unterprogramm Aufruf
Beispiel:
pick (num Row, num Col, bool& Success)
Service:
pick up Bauelement
vom Vorrat an Position (Row, Col) und
setze bei Erfolg die Variable Success auf ‘true’
// Aufrufender Programmteil
bool Erfolg 2, 4, Erfolg
call pick(2, 4, Erfolg)
if Erfolg pick(Row, Col,
…. Erfolg = true Success)
Return

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, 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 • Nachteile:

num ZahlA Die Variablennamen sind fest vergeben.
num ZahlB
num Ergebnis
Nebenläufiger Zugriff von verschiedenen Tasks kann
programm start()
zu erheblichen Problemen führen.
begin
ZahlA = 3 • Wunsch:
ZahlB = 7
Die beiden Zahlen existieren nur für die Dauer der
call avg()
put(“Avg: “) Berechnung.
putln(Ergebnis) Ihre Werte werden als Kopie an das Unterprogramm
end übergeben (by value).
programm avg() Beim Aufruf des Unterprogramms wird festgelegt,
begin wohin das Ergebnis zu schreiben
Ergebnis = (ZahlA+ZahlB)/2 ist (by reference).
end

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.

Teil 2:
Robotik – Programmierung und Handhabung

Teil 6: Praktische Programmierung
(am Beispiel von Stäubli‘s VAL 3 SRS 2016)

6. Praktische Programmierung mit Stäubli‘s SRS 2016
6.1 Übersicht
6.2 Emulator
6.3 Punkte teachen
6.4 Erstellen einer Applikation
6.5 Programmierung
6.6 3D Modellage
6.7 Externe Signale

6.1 SRS 2016 - Übersicht
• Stäubli Robotics Suite starten ()

• Neu -> Wizard für neue Zelle

• Name der Zelle vergeben

• Speicherort festlegen (Achtung C: wird nach dem Herunterfahren gelöscht)
• Standardmäßig werden die Zellen unter C:\Users\XXXX\Documents\Staubli\SRS abgelegt
• Komplette Zelle vorm herunterfahren auf USB Stick speichern

• Hinzufügen einer lokalen Steuerung

• Parameter wie in Abbildung einstellen

• TX90L (Roboter an der OTH im Labor 134)

• Einstellungen aus Abbildung übernehmen

• Unbedingt auf Version s7.9.2 einstellen

• Zellenparameter kontrollieren
• Fertig stellen mit Beenden

Ausgabefenster: Fehlerliste: Globale Variablen

Anzeige für Anzeige von VAL3
Systemmeldungen Syntaxfehlern
Zellenexplorer: Geometrische Ansicht:
Zugriff auf Roboter und Hierarchische Ansicht
Steuerungen der Zelle Der globalen Variablen

CS9 Maintenance und Safety
für Kurs nicht notwendig
Start Ribbon: Allgemeine Werkzeuge und Einstellungen
VAL3 Ribbon: Werkzeuge zur VAL3-Programmierung
Modeling Ribbon: Werkzeuge zur Zellenkonstruktion
Simulation Ribbon: Werkzeuge zur Zellensimulation

6.2 SRS 2016 - Emulator
• Öffnen des Emulators Bei ausgegrauter Schaltfläche

• Funktionen identisch zum Handbediengerät erst den Controller auswählen

• Applikation Stop / Start

• Roboterleistung ein
• Bewegungen freigeben
• Wechsel auf UserPage
• Funktionstasten
• Menü- / Home Taste
• Wechsel der Bedienart
• Bewegungssteuerung für Bedienart
Hand
• Geschwindigkeit in % zur programmierten
Geschwindigkeit

Öffnen einer Applikation im Emulator
1. Enter 2. F7

3. Disk  Pfeiltaste rechts  OK 4. Run

5. OK

6. Start

6.3 SRS 2016 – Punkte teachen
Punkte teachen im Emulator
Punkte nicht geteacht (Video 1) Punkte geteacht (Video 2)

Punkte teachen im Emulator Zum teachen der Punktkoodianten muss ein

bestehendes Werkzeug ausgewählt werden. Im
Emulator muss vorher in den Handbedienmodus
gewechselt und der Play-Button in Simulation
betätigt werden.
1. Point  tGreifer1 wählen

Punkte teachen im Emulator Die Gelenke (Joints) des Roboters lassen

sich mit den +/- Tasten bewegen
2. Joint  tGreifer1 ungefähr zu World ausrichten

Punkte teachen im Emulator Mit der Funktion Ausrichten „Align“

richtet sich das Werkzeug senkrecht
zum gewählten Koordinatensystem
aus (Greifer 1 zu World)
3. Point  Mode (mehrmals bis ALIGN)  Move (gedrückt halten)

Punkte teachen im Emulator Im Bewegungsmuster Frame bewegt

sich der Roboter entlang der Achsen
vom gewählten Referenzsystem.
4. Frame  Zielpunkt mit Pfeiltasten auswählen  zur Zielposition navigieren

pD
pB tGreifer2
tGreifer2 pC
tGreifer1
pA
tGreifer1

Punkte teachen im Emulator Das „@“ vor dem Punkt zeigt an, dass sich das Tool nun an diesem genau
an diesem Punkt befindet.
Weitere Symbole:
! Punkt nicht erreichbar
~ Werkzeug ungefähr an dieser Position
0 Punkt hat noch keine Werte
5. Here  Save 6. Werkzeugwechsel über Select

Nachdem alle Punkte geteacht sind

über Menü in den Applications
Manager wechseln, die Änderungen
noch einmal speichern und das
Programm schließen.
Beim neu öffnen sind die geteachten

Punkte im Programm enthalten.

6.4 SRS 2016 – Erstellen einer Applikation
1. Controller markieren
2. Neue Applikation
3. Name Vergeben
(Speicherort beibehalten)
• Erstellen einer Applikation für die Roboterzelle im Zellen-Explorer

Applikation mit
Unterprogramme
Eigenschaften
des Controllers

1. Applikation markieren
2. Neues Programm
3. Name Vergeben
(Speicherort
beibehalten)
4. Bestätigen
• Erstellen eines neue Programmes im Zellen-Explorer

• Fenster VAL3 Code des neuen Programmes öffnet sich

1. Applikation markieren
2. Neue Globale Variable
3. Typ auswählen
4. Bezeichnung (Typen-
Vorsilbe beachten)
5. Bestätigen
• Erstellen von globalen Variablen

• Wert der Variable ändern durch Doppelklick auf die Variable

• Die Variable Points beschreibt eine Position mit zugehöriger Rotation im Raum
• Ändern der Koordinaten eines Punktes (x, y, z, rx, ry, rz)
• World als Bezugssystem
• Achtung bei Gelenkkonfiguration

• Konfiguration shoulder für diesen Punkt

• righty: d1 * sin(Φ2) + d2 * sin(Φ2+Φ3) + λ < 0
• lefty: d1 * sin(Φ2) + d2 * sin(Φ2+Φ3) + λ ≥ 0
• ssame: Steuerung darf Konfiguration nicht selbstständig ändern
es wird der Vorherige Zusand eingehalten
• sfree: Steuerung darf Konfiguration selbstständig verändern
– VERBOTEN !
• D1: Länge des Roboters

• D2: Unterarmlänge
• Φ2 : Winkel Achse 2
• Φ3 : Winkel Achse 3
• Λ: Abstand Achse 1 zu 2
in X-Richtung

• Konfiguration elbow für diesen Punkt

• epositive: Winkel Achse 3 ≥ 0
• enegative: Winkel Achse 3 < 0
• esame: Steuerung darf Konfiguration nicht selbstständig ändern
• efree: Steuerung darf Konfiguration selbstständig verändern
– VERBOTEN !

• Konfiguration wrist für diesen Punkt

• wpositive: Winkel Achse 5 ≥ 0
• wnegative: Winkel Achse 5 < 0
• wsame: Steuerung darf Konfiguration nicht selbstständig ändern
• wfree: Steuerung darf Konfiguration selbstständig verändern
– VERBOTEN !

• Die Variable Joints beschreibt den Winkel jeder Roboterachse

• Ändern der einzelnen Winkel einer Gelenkkonfiguration (j1, j2, j3, j4, j5, j6)
• Joints besitzen kein Bezugssystem

• Die Variable Tool definiert Abstand und Rotation vom TCP zum Flange
• Der TCP (Tool Center Point) ist der Arbeitspunkt eines Werkzeuges
• Ändern der Parameter eines Werkzeuges (x, y, z, rx, ry, rz)

• Frames weitere Referenzsysteme neben World

• Ändern der Koordinaten eines Frames (x, y, z, rx, ry, rz)
• World als Bezugssystem

• Unter Geometrische Beschreibung sind die Bezüge der Elemente untereinander ersichtlich
(Bezugssystem für pA ist World)

• pA - bezüglich World  trsf (200|200|200|0|0|0)

• Ein Ändern dieser Bezüge ist mittels Drag and Drop möglich (neues Bezugssystem für pA ist
Frame1)

• pA - bezüglich Frame1  (200|200|200|0|0|0)

• fFrame1 - bezüglich World  (100|100|0|0|0|0)
• pA - bezüglich World  (300|300|200|0|0|0)

Speichern
Simulation starten
Betriebsmodus „Hand“
Arm einschalten
• Punkt über Emulator anfahren

Punkt über Pfeiltaste

markieren
„Move“ führt
Bewegung aus
Arm bewegt sich auf

Punkt pA
• Punkt über Emulator anfahren

6.5 SRS 2016 – Programmierung
Code-Beispiel
• Programmierung mit VAL3

6.5 SRS 2016 – Programmierung
• Alle Programmcodes unter:

Home  Hilfe  VAL3 Hilfe  VAL3 Referenzanleitung  Index

6.5 SRS 2016 – Programmierung - UserPage
Programmcodes UserPage
void userPage() Automatischer Wechsel zur User Page beim Erreichen

der Codezeile
void cls() löscht alle Daten auf der User Page
void title(string sText) setzt den Titel der User Page
void gotoxy(num nX, num setzt den Cursor auf die Stelle (x,y)
nY)
void put(num nWert) Schreibt die Zahl oder den Text an die aktuelle Cursor
void put(string sText) Position
void putln(num nWert) Wie put, aber mit zusätzlichem Zeilenumbruch
void putln(string sText)
num clock() Liefert den aktuellen Wert der internen Uhr
Beim Booten wird der Wert wieder auf 0 gesetzt

6.5 SRS 2016 – Programmierung - UserPage
• User Page
(39, 0)
(0, 0)
Y
(0, 13)
• Cursor Positionen für gotoxy()

• XUserPage (0 bis 39) Über die UserPage können Befehle,
• YUserPage (0 bis 13) Programmzustände, … ausgegeben werden

6.5 SRS 2016 – Programmierung -Tasteneingabe
Programmcodes Tastatureingabe
num get(num& nWert) Wartet auf Bestätigung der Eingabe mit ENTER oder
num get(string& sText) ESC
num get() Wartet auf Tastendruck und gib den ASCII Code der
zuerst gedrückten Taste
num get(Key) Gibt den Unicode der zuletzt gedrückten Taste aus
Wenn keine Taste gedrückt wurde ist die Rückgabe -1
bool isKeyPressed(num nCode) Gibt true aus, wenn die Taste noch gedrückt ist

6.5 SRS 2016 – Programmierung – Syntaxprüfung
()
Autovervollständigung
nutzen um Tipp- bzw.
Syntaxfehler zu Vermeiden!
• Syntaxprüfung um Fehler im Quellcode zu finden

6.5 SRS 2016 – Programmierung – Anweisungen /Schleifen
Verzweigungen und Schleifen
Anweisung if if … elseIf … else … endIf
Anweisung switch switch … case … default … endSwitch
Anweisung for for … endFor
Anweisung while while … endWhile
Anweisung do … until do … until
Operatoren
< kleiner > größer
== gleich != ungleich
>= größer-gleich <= kleiner-gleich
and und or oder
xor exklusiv oder ! bool nicht true

Anweisung if Beispiel

Anweisung switch Beispiel

Anweisung for Beispiel
Pro Sekunde erscheint eine neue Zeile

Anweisung while Beispiel

Anweisung do … until Beispiel

6.5 SRS 2016 – Programmierung - Unterprogramme
Unterprogramme aufrufen
call Programm(…) aufrufen eines Programmes

6.5 SRS 2016 – Programmierung - Multitasking
Multitasking
void taskCreate string sName, num nPriorität, Programm(…)
Taskname beim Priorität, Name des zu

debuggen abzuarbeitende Zeilenzahl startenden
Programms

Priorität
– Gibt an wie viele Programmzeilen am Stück abgearbeitet werden, bevor der nächste Task
bearbeitet wird
– Werte von 1 bis 100 sind zulässig
– Abgeben an den nächsten Task bei folgenden Befehlen auch wenn die angegebene
Zeilenanzahl noch nicht erreicht ist:
 watch(), delay(), wait(), waitEndMove(), setMutex()
 Open(), close()
 Get()
 disablePower()
 taskResume(), taskKill()
 libLoad(), libSave(), libDelete(), libList(), setProfile()
 sioGet(), sioSet(), bei Operator „=“

Multitasking
void taskCreate string sName, num nPriorität, Erzeugt neuen Task

Programm(…)
void taskKill(string sNamen) Zerstört Task
void taskSuspend(string sName) Hält Task an
void taskResume(string sName, num nSprung) Task wieder aufnehmen
num taskStatus(string sName) Status des Tasks
nSprung
– = 0 - weiter ab aktueller Zeile
– > 0 - weiter an „nSprung“-Zeilen nach der aktuellen Zeile *
– < 0 - weiter an „nSprung“-Zeilen vor der aktuellen Zeile *
* Vermeiden! Kann zu Problemen führen.

6.5 SRS 2016 – Programmierung - Multitaskting
Taskstatus

6.5 SRS 2016 – Programmierung - Bewegungssteuerung
Fahrbefehle
mdesc mDesc (neue globale Variable) Motiondescriptor
num movej(joint jPosition, tool tWerkzeug, mdesc mDesc) Achsinterpolation
(Joint)
num movej(point pPosition, tool tWerkzeug, mdesc mDesc) Achsinterpolation
(Point)
num movel(point pPoint, tool tWerkzeug, mdesc mDesc) Kartesische
Interpolation
num movec(point p1, point pZiel, tool tWerkzeug, mdesc mDesc) Kreisinterpolation
void waitEndMove() Verhindern von

Blending
bool isSettled() * Roboter steht still
* isSettled() sollte nur mit vorhergehender Bedingung waitEndMove()

verwendet werden

• Anlegen eines Motiondescriptors

• Die Variable mdesc beschreib wie die Fahrbefehle ausgeführt werden

• Accel, Vel, Decel: % der nominalen Achswerte

• Tvel: max. Translationsgeschwindigkeit in mm/s am TCP
• Rvel: max. Rotationsgeschwindigkeit in Grad/s am TCP
• Blend: Joint oder Cartesian

• Leave: Abstand in mm wann der Roboter von der Bahn abweichen darf
• Reach: Abstand in mm wann der Roboter die Bahn wieder erreichen muss

Blending
• Bei waitEndMove() wird der Anschlussbewegung zu Punkt C erst ausgeführt, wenn Punkt B
erreicht wurde

Anweisung movej()
– Achsinterpolation
– Nichtgeradlinige Bewegung
– Keine Probleme mit Singularitäten
– Bahnkurve nur grob vorherzusehen

Anweisung movel()
– Kartesische Interpolation
– Geradlinige Bewegung
– Probleme mit Singularitäten  slow down
– Bahnkurve genau vorherzusehen

Anweisung movec()
– Kreisinterpolation
– Kreisförmige Bewegung
– Probleme mit Singularitäten  slow down
– Bahnkurve genau vorherzusehen
– Vollkreis durch 4 Punkte definiert

VAL3-Anwendung und Roboterbewegung
• Programm und Roboterbewegungen werden unabhängig zueinander ausgeführt!

Motion Stack
void stopMove() Befehl hält Arm an und blockiert programmierte

Bewegung
void restartMove() Befehl gibt blockierte Bewegung wieder frei
void resetMotion() Befehl hält Roboter an und löscht Motion Stack
void resetMotion(joint jStart) Wie resetMotion() mit zusätzlicher Rückkehr zu jStart
bool isEmpty() Liefert true, wenn der Motion Stack leer ist
• Die Roboterbewegung kann auch immer folgendermaßen angehalten werden

– Move/Hold-Taste drücken
– Armleistung ausschalten
– Betriebsart wechseln
– Bremswahlschalter am Roboterfuß betätigen
• Das VAL3 Programm läuft weiter und wird nicht unterbrochen

• Erstellen von Grundkörpern in der 3D Ansicht

• Komplette 3D-Modellierung der Roboterzelle siehe Kapitel 6.6

• Erstellen von Grundkörpern in der 3D Ansicht


• Referenzsystem für 3D Komponenten

• Die Z-Koordinate beträgt 500 mm

• TCP Koordinaten beim Anfahren des Punktes

• Referenzsystem World
• Die Z Koordinate für den Punkt Beträgt 22 mm

• Versatz in Z um 478 mm
• Bezugssystem 3D Ansicht

Berechnung mit Punkten
Berechnung von Punkten
point appro(point pPosition, trsf Berechnung eines Punktes in Bezug

trTransformation) auf eine Punkt
point here(tool tWerkzeug, frame fFrame) Liefert Position von TCP in einem
Frame
point jointToPoint(tool tWerkzeug, frame fFrame, joint jPosition)
Liefert position von TCP mit Ausgabe als Point, Armkonfiguration bleibt in Joint
bool pointToJoint(tool tWerkzeug, joint BspPoint, point pPosition, joint& jResult)
Beschreibung siehe VAL3 Anleitung

Verschiebung zu einem Punkt
appro(pPunkt,{0,0,100,0,0,0})
(generierter Punkt)
100 mm
pPunkt
(originaler Punkt)
Appro generiert einen neuen Punkt mit Bezug auf einen bestehenden Punkt unter
Angabe der Transformation.

Komplexes Annähern an einen Punkt
Undefinierte
Position
X+200
Z+100
X+200
Z+100
Z+100
Z+100 Zielpunkt erreicht

Komplexes Annähern an einen Punkt
VAL3 Code

Komplexes Bewegen um einen Punkt
Vorzeichen beachten!
(rechte Hand Regel)
30°

6.6 SRS 2016 –3D Modellage

6.6 SRS 2016 – 3D Modellage
Achswinkel
(0,0,0,0,0,0)
Über rechtsklick auf den
Roboter
• Werkzeuge an den Roboterarm montieren

• CAD Modell auswählen

• Werkzeug an den Roboter montieren

Geometrie als Neues

Tool definieren …
… und dieses an den Handler des TX90L montieren.

Werkzeug sitzt falsch

Am Roboterarm …
… beim Montieren werden die beiden Referenzframes

aufeinander gelegt.

• Tool demontieren und löschen  Greifer erscheint wieder unter Geometrien

• Hinzufügen eines Hilfs Frames am Flansch des Werkzeuges

Punkt 1 …
… Punkt 2 …
• Drei Referenzpunkte am Werkzeugflansch wählen

… Punkt 3

Hilfs Frame am Greifer-Flansch
Hilfs Frame auf Handler am Roboter-Flansch ausrichten
Absolute Position des Hilfs Frames notieren

• Referenzframe bearbeiten  Werte des Hilfs Frames in Absolute Position übernehmen

• Referenzframe des Greifers an der richtigen Stelle  Bearbeitung beenden (Klick auf
„Referenzframe bearbeiten“)

• Greifer-Geometrie als Neues Tool definieren und an den Handler vom TX90L montieren

• Greifer ist richtig am Roboter positioniert

• Handler bzw. TCP (Tool Center Point) sitzt nicht an der Spitze des Greifers

• Greifer demontieren  Tool löschen

 Hilfs Frame für TCP festlegen

Hilfs Frame TCP an der Greiferspitze
Absolute Position des TCP Hilfs Frame

Handler „Bearbeiten“
Absolute Position von TCP Hilfs Frame übernehmen

• Handler Ausrichtung anpassen

• Roboter auf Gelenkkonfiguration (0,45,45,0,45,0) stellen

• Handler bzw. TCP hat die gleiche Ausrichtung wie World

• Sinnvoll?

• Handler – rechte Maustaste – Tooldaten kopieren

• Tooldaten in entsprechender globalen Tool Variable einfügen

• Einbau von Geometrien in die Roboterzelle (Bsp. Arbeitstisch)

• CAD Modell einfügen

• Durch Drehen um die Achsen des Koordinatensystems (nur 90° Schritten) zum Roboter
Ausrichten

• Frame auf eine Befestigungsbohrung des Roboters setzen und zum Welt-Koordinatensystem
ausrichten

• Aktuelle Position dieses Frames notieren

• Weiteren Frame auf entsprechende Bohrung am Roboter setzen, Ausrichten und Werte notieren

• Referenzframe des Tisches bearbeiten

• Tisch auf Absolute Position (0,0,0,0,0,0) setzen

• Die Geometrie ist fertig verbaut

6.5 SRS 2016 – Programmierung – Externe Signale
Ethernetsocket (Bsp. Bildverarbeitung)
Interner Ventilblock
Modbus (Bsp. Wago SPS)

6.6 SRS 2016 – Programmierung – Externe Signale – Interne Ventile
• Der Stäubli TX 90 L verfüg bereits werksseitig pneumatische Ventile in seinem Standfuß. Diese
sind bereits in der Entwicklungsumgebung hinterlegt.
• Entsprechende Tool Variable anklicken – Doppelklick auf Gripper – Ventil auswählen

6.6 SRS 2016 – Programmierung – Externe Signale – Interne Ventile
• Alternativ kann ein Dio (digitaler Ein-/Ausgang) mit dem entsprechenden Ventil belegt werden
• Die Ansteuerung des Ventil erfolgt über die Zuweisung „true“ bzw. „false“

6.6 SRS 2016 – Programmierung – Externe Signale - Modbus
• Über eine Modbus können zum Beispiel die Signale einer SPS eingebunden werden
• Die Art und Anzahl aller Karten der angeschlossenen SPS muss angelegt werden

• Die modbus.xml Datei muss in der Zelle unter „Modbus“ gespeichert werden
• Die entsprechenden Ein- / Ausgänge stehen nun zur Verfügung

• Die Verknüpfung der SPS Signale mit den globalen Variablen erfolg nach dem gleichen Prinzip
wie bei den internen Ventilen

6.6 SRS 2016 – Programmierung – Externe Signale – Ethernet Socket
Namen vergeben
IP Adresse des eigenen Rechners
Realisieren des Ethernet Sockets

mit Simulationsmöglichkeit über den PC

• Erstellen einer globalen Variable sio

• Verknüpfen des Sockets mit der Variable

Verzeichnis des Java Serverprogrammes aufrufen
Serverprogramm starten (java –jar ServerConsole.jar 23)
Sobald der Socket in der Val3 Applikation aufgerufen wird zeigt das
Serverprogramm „connected“

• Nachrichten / Befehlen können an den Emulator übertragen werden

Impressum
Autor: B. Eng. Michael Uschold
Herausgegeben durch: Teilprojekt #aufstieggestalten 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

othmind@oth-aw.de
www.oth-aw.de/oth-mind
Copyright: Dieses Kursmaterial ist lizenziert unter einer Creative Commons Namensnennung –
Weitergabe unter gleichen Bedingungen 4.0 International Lizenz (CC BY-SA 4.0). Bei einer
Weitergabe soll der Name des Urhebers wie folgt genannt werden: „Michael Uschold, OTH
mind #aufstieggestalten, OTH Amberg-Weiden“.
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 des Autors.

Skript Robotik-Programmierung Und Handhabung Final

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Skript Robotik-Programmierung Und Handhabung Final

Hochgeladen von

Copyright:

Verfügbare Formate

Robotik – Programmierung und Handhabung

Teil 1: Einführung in die Programmierung für Robotik

BMBF-Verbundprojekt OTH mind

BMBF-Verbundprojekt OTH mind S. 2

Begriffe, Typen von Robotern und Anwendungsgebiete

BMBF-Verbundprojekt OTH mind S. 3

BMBF-Verbundprojekt OTH mind S. 4

BMBF-Verbundprojekt OTH mind S. 5

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

DIN 66 312: Industrieroboter – Programmiersprache, Industrial Robot Language

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

DIN EN ISO 9787: Industrieroboter – Koordinatensysteme und

BMBF-Verbundprojekt OTH mind S. 6

VDI 2740 Blatt 1: Mechanische Einrichtungen in der Automatisierungstechnik –

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

VDI 2861: Montage- und Handhabungstechnik – Kenngrößen für Blatt 1 … 3

BMBF-Verbundprojekt OTH mind S. 7

BMBF-Verbundprojekt OTH mind S. 8

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

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

1921 Im Science-Fiction-Theaterstück „Rossum‘s Universalroboter“ von Karel Capek taucht

1952 Prototyp einer NC-Maschine am MIT, Entwicklung der Programmiersprache APT

BMBF-Verbundprojekt OTH mind S. 9

1961 Erster Roboter der Fa. Unimate bei Ford installiert

1971 Deutschland: Erster Roboter bei Daimler-Benz

1975 SIGMA Roboter von Olivetti

BMBF-Verbundprojekt OTH mind S. 10

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

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.

BMBF-Verbundprojekt OTH mind S. 11

BMBF-Verbundprojekt OTH mind S. 12

BMBF-Verbundprojekt OTH mind S. 13

Manuell gesteuert Programm gesteuert

BMBF-Verbundprojekt OTH mind S. 14

• Ein Industrieroboter ist kein Teleoperator

• Ein Industrieroboter ist kein Einlegegerät

BMBF-Verbundprojekt OTH mind S. 15

BMBF-Verbundprojekt OTH mind S. 16

Autonome Roboter / Agentensysteme (Forschung)

BMBF-Verbundprojekt OTH mind S. 17

BMBF-Verbundprojekt OTH mind S. 18

BMBF-Verbundprojekt OTH mind S. 19

BMBF-Verbundprojekt OTH mind S. 20

BMBF-Verbundprojekt OTH mind S. 21

BMBF-Verbundprojekt OTH mind S. 22

BMBF-Verbundprojekt OTH mind S. 23

BMBF-Verbundprojekt OTH mind S. 24

BMBF-Verbundprojekt OTH mind S. 25

BMBF-Verbundprojekt OTH mind S. 26

BMBF-Verbundprojekt OTH mind S. 27

BMBF-Verbundprojekt OTH mind S. 28

BMBF-Verbundprojekt OTH mind S. 29

Koordinatensysteme, Transformation, Bewegungssteuerung

BMBF-Verbundprojekt OTH mind S. 30

2.1 Kinematische Grundtype

2.2 Arbeits- und Kollisionsraum

2.3 Koordinaten und Transformation

2.4 Beschreibung einer Roboterstellung

2.5 Die kinematische Kette

2.6 Die kinematische Vorwärtstransformation

2.7 Die kinematische Rückwärtstransformation