Modellierung und Simulation von Zerspanverfahren mithilfe...

Modellierung und Simulation von

Zerspanverfahren mithilfe der

Durchdringungsrechnung am Beispiel des

Wälzfräsens

Diplomarbeit

vorgelegt im Fachbereich 3

Studiengang Informatik

der

Universität Bremen

Sascha Debie

Gutachter: Prof. Dr.-Ing. Karl-Heinz Rödiger

Dr.-Ing. Jens Sölter

Bremen, Februar 2011

Inhaltsverzeichnis 2

Inhaltsverzeichnis

Inhaltsverzeichnis ......................................................................................................... 2

Abbildungsverzeichnis ................................................................................................. 5

Tabellenverzeichnis ...................................................................................................... 6

Abkürzungen und Formelzeichen ............................................................................... 7

1 Einleitung ............................................................................................................ 8

1.1 Ziel und Motivation .................................................................................... 8

1.2 Struktur der Ausarbeitung ......................................................................... 9

2 Grundlagen und Stand der Technik ............................................................... 10

2.1 Fachbegriffe und Definitionen ................................................................. 10

2.2 Wälzfräsen .............................................................................................. 12

2.2.1 Axialwälzfräsen .................................................................................. 16

2.2.2 Schlagzahnfräsen .............................................................................. 17

2.2.3 Softwareunterstützung für das Schlagzahnfräsen ............................. 20

2.3 Bestehende Lösungen ............................................................................ 21

2.3.1 FRS ................................................................................................... 21

2.3.2 SPARTApro ....................................................................................... 22

2.3.3 FRS/MAT ........................................................................................... 23

2.3.4 HOB3D .............................................................................................. 24

2.3.5 Hobicam ............................................................................................ 25

2.3.6 Abgrenzung ....................................................................................... 26

2.4 Datenmodelle, Formeln und Algorithmen ............................................... 27

2.4.1 Diskretisierung ................................................................................... 27

2.4.2 Mathematische Beschreibung der Kinematik beim Wälzfräsen ........ 29

2.4.3 Polygonschnitt ................................................................................... 33

2.4.4 Flächenberechnung von Polygonen .................................................. 35

2.5 Fazit ........................................................................................................ 36

3 Zielsetzung und Vorgehensweise .................................................................. 37

3.1 Zielsetzung ............................................................................................. 37

3.2 Vorgehensweise ..................................................................................... 37

3.3 Vereinfachter Programmablauf ............................................................... 37

3.3.1 Dateneingabe .................................................................................... 39

3.3.2 Simulation .......................................................................................... 39

3.3.3 Datenausgabe ................................................................................... 39

4 Anforderungen ................................................................................................. 40

4.1 Anwendungsfälle .................................................................................... 40


4.2 Funktionale Anforderungen .................................................................... 42

4.2.1 Allgemeines ....................................................................................... 42

4.2.2 Dateneingabe der Simulationsparameter .......................................... 43

4.2.3 Einlesen von Geometriedaten ........................................................... 43

4.2.4 Berechnung von Simulationskenngrößen .......................................... 43

4.2.5 Durchführung der Durchdringungsrechnung ..................................... 43

4.2.6 Visualisierung .................................................................................... 44

4.2.7 Export der Simulationsergebnisse ..................................................... 44

4.2.8 Unterstützung von Mehrmonitorsystemen ......................................... 44

4.2.9 Abgrenzungskriterien ......................................................................... 44

4.3 Nicht funktionale Anforderungen ............................................................ 45

4.3.1 Performanz ........................................................................................ 45

4.3.2 Qualitätsanforderungen / Genauigkeit ............................................... 45

4.3.3 Benutzbarkeit ..................................................................................... 45

4.3.4 Einbettungsanforderung / Erweiterbarkeit ......................................... 45

4.3.5 Dokumentation .................................................................................. 45

4.3.6 Einführungsanforderungen ................................................................ 46

4.4 Umgebung .............................................................................................. 46

4.4.1 Technische Umgebung ...................................................................... 46

4.4.2 Entwicklungsumgebung ..................................................................... 47

5 Systementwurf ................................................................................................. 48

5.1 Software-Prototyp JCut ........................................................................... 48

5.1.1 Aufbau ............................................................................................... 48

5.1.2 Visualisierung .................................................................................... 48

5.2 Parameter, Datenformate und Datenstrukturen ...................................... 49

5.2.1 Diskretisierung ................................................................................... 49

5.2.2 Simulationsparameter und Optionen ................................................. 52

5.2.3 Eingabeformat der Geometriedaten .................................................. 57

5.2.4 Ausgabeformat der Simulationsdaten des Exportmoduls .................. 58

5.3 Externe Software sowie verwendete Bibliotheken .................................. 58

5.4 Klassen ................................................................................................... 59

5.5 Kinematik von Wälzfräser und Werkstück .............................................. 60

5.6 Durchdringungsrechnung ....................................................................... 61

5.6.1 Zeitdiskretisierung ............................................................................. 62

5.6.2 Polygonschnitt nach Weiler-Atherton ................................................ 62

6 Implementierung .............................................................................................. 64

6.1 Zeitlicher Ablauf und Komponenten ........................................................ 64

6.2 Weiler-Atherton-Algorithmus ................................................................... 64

6.2.1 Schnittpunkte ..................................................................................... 64

6.2.2 Sonderfälle ........................................................................................ 65

6.3 Kinematikberechnungen ......................................................................... 68

6.3.1 Synchronisation zwischen Werkzeug und Werkstück ....................... 68


6.3.2 Kinematik und Visualisierung mit Java3D ......................................... 70

7 Ergebnisse und Bewertung ............................................................................ 72

7.1 JCut ........................................................................................................ 72

7.1.1 Benutzungsoberfläche ....................................................................... 72

7.1.2 2D-Visualisierung .............................................................................. 73

7.1.3 3D-Visualisierung .............................................................................. 74

7.1.4 Export der Ergebnisse ....................................................................... 75

7.2 Test des Prototyps .................................................................................. 76

7.3 Evaluation ............................................................................................... 76

7.3.1 Anforderungen ................................................................................... 76

7.3.2 Genauigkeit der Durchdringungsrechnung ........................................ 77

7.3.3 Aussagekraft der simulierten Spanungsquerschnitte ........................ 79

8 Zusammenfassung und Ausblick ................................................................... 85

8.1 Ausblick .................................................................................................. 85

Anhang A: Inhaltsverzeichnis der CD ....................................................................... 87

Anhang B: Simulationsdaten ..................................................................................... 88

Glossar ......................................................................................................................... 90

Literaturverzeichnis .................................................................................................... 93

Erklärung ..................................................................................................................... 97

Abbildungsverzeichnis 5

Abbildungsverzeichnis Abbildung 1: Begriffe beim Prozess der Spanung .................................................. 11

Abbildung 2: Beispiel einer Durchdringungsrechnung ............................................ 11

Abbildung 3: Geometrische Kenngrößen eines Wälzfräsers ([Weigel], S. 35) ....... 12

Abbildung 4: Paarung Wälzfräser-Werkstück am Beispiel des Wälzfräsens ([Klocke 2008], S. 441) ...................................................................... 14

Abbildung 5: Zusammenhang der Gangzahl und Spannuten mit den Wälzstellungen ([Obermeier 2006], S. 10) ........................................ 15

Abbildung 6: Axialwälzfräsen .................................................................................. 17

Abbildung 7: Schlagzahnfräsen ([Bouzakis 2008], S. 680) .................................... 20

Abbildung 8: SPARTApro [SPARTApro 2010] ....................................................... 23

Abbildung 9: FRS/MAT ([Bouzakis 2008], S. 679) ................................................. 24

Abbildung 10: HOB3D ([Vasilis 2007], S. 916) ......................................................... 25

Abbildung 11: SolidWorks-Modul Hobicam ([Hobicam 2010], S. 14) ....................... 26

Abbildung 12: Koordinatensystem ([Sulzer 1973], S. 29) ......................................... 29

Abbildung 13: Polygonschnitt ................................................................................... 34

Abbildung 14: Trapezflächen eines Polygons .......................................................... 36

Abbildung 15: Ablaufdiagramm der Durchdringungsrechnung (Schlagzahnfräsen) ........................................................................... 38

Abbildung 16: JCut Anwendungsfalldiagramm ......................................................... 42

Abbildung 17: Geometrie eines Würfels ................................................................... 49

Abbildung 18: CSV-Daten Schneidprofil ................................................................... 58

Abbildung 19: Zusammenhang Rotationsachse - Ursprungsvektor ......................... 61

Abbildung 20: Weiler-Atherton-Sonderfälle .............................................................. 65

Abbildung 21: Weiler-Atherton-Sonderfallbehandlung ............................................. 67

Abbildung 22: JCut-Benutzungsoberfläche .............................................................. 72

Abbildung 23: JCut-2D-Visualisierung ...................................................................... 74

Abbildung 24: JCut-3D-Visualisierung ...................................................................... 75

Abbildung 25: Geometrisches Modell für die analytische Untersuchung ................. 79

Abbildung 26: Abweichung der Spanungsquerschnitte in Variation 01 .................... 82

Abbildung 27: Abweichung der Spanungsquerschnitte in Variation 16 .................... 84

Abbildung 28: Evolvente ........................................................................................... 90

Tabellenverzeichnis 6

Tabellenverzeichnis Tabelle 1: Beteiligung der Gänge an Zahnlücken .............................................. 15

Tabelle 2: Freiheitsgrade beim Axialwälzfräsen und Schlagzahnfräsen ............ 18

Tabelle 3: Gegenüberstellung der Diskretisierungsvarianten bei der Durchdringungsrechnung/Wälzfräsen, insbesondere Schlagzahnfräsen. ............................................................................ 50

Tabelle 4: JcutNode Feldnamen ........................................................................ 51

Tabelle 5: Einstellbare Simulationsparameter in JCut ........................................ 52

Tabelle 6: Errechnete Simulationskenngrößen in JCut ...................................... 55

Tabelle 7: Simulationsoptionen in JCut .............................................................. 55

Tabelle 8: Steuerungselemente in JCut ............................................................. 56

Tabelle 9: JCut-Variablen für die Synchronisation zwischen Werkzeug und Werkstück ......................................................................................... 69

Tabelle 10: Analytischer Vergleich / Variationen .................................................. 80

Tabelle 11: Vergleich analytischer und simulierter Spanungsquerschnitte (Variation 01) ..................................................................................... 81

Tabelle 12: Vergleich analytischer und simulierter Spanungsquerschnitte (Variation 16) ..................................................................................... 83

Abkürzungen und Formelzeichen 7

Abkürzungen und Formelzeichen

Abkürzungen

API Application Programming Interface

AWT Abstract Window Toolkit

FEM Finite-Elemente-Methode

IWT Institut für Werkstofftechnik Bremen

PZH Produktionstechnisches Zentrum Hannover

RWTH Rhein-Westfälische Technische Hochschule

SQ Spanungsquerschnitt(e)

SWT Standard Widget Toolkit

WST Werkstück

WZ Werkzeug

WZL der RWTH Werkzeugmaschinenlabor der RWTH

Formelzeichen

Symbol Einheit Bezeichnung

2 ° bzw. rad Schrägungswinkel der Verzahnung

° bzw. rad Steigungswinkel des Wälzfräsers

- Stollen- bzw. Spannutenzahl

mm Axialvorschub

mm Radialvorschub

mm Tangentialvorschub

mm Tangentialvorschub pro Werkradumdrehung

° bzw. rad Neigungswinkel des Wälzfräsers

mm Modul

mm Tauchtiefe

- Gangzahl

Einleitung 8

1 Einleitung

Wie kann man den komplexen Vorgang des Wälzfräsens, als Analogieversuch in Form

des Schlagzahnfräsens, mithilfe einer computergestützten Durchdringungssimulation

nachbilden, um diesen Fräsprozess mit geometrisch bestimmter Schneide zu untersu-

chen sowie aufgrund der gewonnenen Erkenntnisse zu optimieren?

Wie kann man diesen Prozess mit seiner durch sechs Freiheitsgrade bestimmten Ki-

nematik simulieren und dabei das sich bildende Zahnrad sowie die anfallenden Späne

ermitteln?

Wie können diese Ergebnisse ausgewertet und weiterverarbeitet werden?

Welche Fehler entstehen durch die Diskretisierung des Prozesses und wie können

diese durch entsprechende Parameter beeinflusst werden?

Diese Fragestellungen sind der Ausgangspunkt dieser Arbeit. In den folgenden Kapi-

teln beschäftige ich mich mit deren Beantwortung sowie der Entwicklung eines experi-

mentellen Software-Prototyps. Mit diesem Prototyp soll eine Basis geschaffen werden,

mit der verschiedene Ansätze und Algorithmen auf Tauglichkeit geprüft werden kön-

nen.

1.1 Ziel und Motivation

Neben meinem Studium habe ich am Institut für Werkstofftechnik (IWT) an der Univer-

sität Bremen als Hilfswissenschaftler gearbeitet. Dort gehörte der Umgang mit Simula-

tionssoftware ebenso wie das Programmieren von Eingabe- und Ausgaberoutinen zu

meinen Aufgaben. Obwohl der Fachbereich 4 – Produktionstechnik, Maschinenbau &

Verfahrenstechnik – auf den ersten Blick nicht viele Überschneidungen mit unserem

Fachbereich 3 – Mathematik & Informatik – hat, habe ich während meiner Tätigkeit

festgestellt, dass es in diesem Fachbereich, insbesondere im Bereich der Simulationen

von Fertigungsprozessen, diverse Fragestellungen gibt, für die die Informatik Antwor-

ten liefern kann.

Nach der Anschaffung einer Wälzfräsmaschine für den Bereich Fertigungstechnik des

IWT, kamen Dr.-Ing. Jens Sölter und Tim Kohlhoff mit der Idee für eine Diplomarbeit im

Rahmen des Fachbereichs 3 auf mich zu.

Trotz anfänglicher Skepsis aufgrund der Fachbereichsüberschneidungen habe ich mit

Prof. Dr.-Ing. Karl-Heinz Rödiger eine Fragestellung für den Fachbereich 3 herausge-

arbeitet und mich, aufgrund meiner eigenen Begeisterung für Simulationssoftware, der

Herausforderung gestellt.

Einleitung 9

Ziel dieser Arbeit ist es, den Prozess des Wälzfräsens, hier speziell des Schlagzahn-

fräsens, mit einem Software-Prototyp nachzubilden und die Ergebnisse zu bewerten.

Dabei geht es um eine Durchdringungsrechnung, die sowohl das gefräste Werkstück

als auch die dabei entstehenden Spanungsquerschnitte beschreiben soll. Ferner soll

der Software-Prototyp im IWT eingesetzt und weiterentwickelt werden. Die Untersu-

chungen anhand des Schlagzahnfräsens, auf das später noch genauer eingegangen

wird, sind insofern sinnvoll, da es sich um einen Analogieversuch des Wälzfräsprozes-

ses handelt. Der Software-Prototyp soll das Schlagzahnfräsen soweit abbilden, dass

die Grundfunktionalität für das Erzeugen von Simulationsergebnissen vorhanden ist

und diese Ergebnisse ausgewertet bzw. weiterverarbeitet werden können.

1.2 Struktur der Ausarbeitung

Da sich die Arbeit mit einer fachbereichsübergreifenden Problemstellung befasst, wer-

de ich in Kapitel 2 die Grundlagen vorstellen. Dabei gehe ich nach der Einführung von

Fachbegriffen zuerst auf das Wälzfräsen sowie das Schlagzahnfräsen im Besonderen

ein. In dem Kapitel soll allerdings nur ein Überblick geschaffen werden, der dem Rah-

men dieser Arbeit angemessen ist. Das Wälzfräsen ließe sich um ein Vielfaches detail-

lierter beschreiben, was aber für das Verständnis dieser Arbeit nicht erforderlich ist. An

der entsprechenden Stelle wird auf weiterführende Literatur zu diesem Thema verwie-

sen. Das Kapitel 2.3 widmet sich dem Thema „Bestehende Lösungen“ und sucht nach

ähnlichen bzw. bereits vorhandenen Lösungen. In Kapitel 2.4 werden Datenmodelle,

Formeln und Algorithmen als Stand der Technik eingeführt, die sich mit den in dieser

Arbeit beschriebenen Problemen befassen.

Kapitel 3 konkretisiert die Zielsetzung sowie die Vorgehensweise und zeigt die Durch-

dringungsrechnung in vereinfachter Form. In Kapitel 4 werden Anforderungen definiert,

welche in Kapitel 5 zu einem Softwareentwurf führen, um daraus in Kapitel 6 die Im-

plementierung des Software-Prototyps hervorgehen zu lassen.

Kapitel 7 resümiert die Arbeit und liefert die Ergebnisse sowie deren Bewertung. An-

schließend wird im 8. Kapitel neben der Zusammenfassung ein Ausblick über die Er-

weiterungsmöglichkeiten des Software-Prototyps aufgezeigt.

Grundlagen und Stand der Technik 10

2 Grundlagen und Stand der Technik

2.1 Fachbegriffe und Definitionen

Im Verlauf dieser Arbeit werden die folgenden Begriffe, insbesondere der Begriff „Spa-

nungsquerschnitt“, häufiger vorkommen. Anhand der Abbildung 1 wird die Abgrenzung

zwischen diesen Begriffen verdeutlicht.

Span

Der Span beschreibt den Teil des Werkstücks, der beim Spanen abgetragen wurde.

Die Form des Spans ist schwer vorherzusagen, da in dem Prozess des Spanens Kräfte

in Wärme umgewandelt werden. Dies führt dazu, dass sich der Span verdrehen, ver-

glühen, aufwickeln oder allgemein verformen kann. Darüber hinaus verläuft der Pro-

zess des Spanens nicht kinematisch gleichmäßig. Durch eine komplexe Kinematik des

Prozesses kann die Form des Spans stark variieren.

Spandicke

Die Spandicke beschreibt die Dicke (Höhe) des abgetragenen Spans. Sie muss bei

einem gleichmäßig abgetragenen Span aus den oben genannten Gründen nicht an

allen Stellen des Spans identisch sein.

Spanbreite

Analog zu der Spandicke ist hiermit die Breite des abgetragenen Spans gemeint.

Spanungsdicke

Die Spanungsdicke beschreibt die Höhe des abzutragenden Materials und ist nicht

zwangsläufig gleich der Spandicke.

Spanungsbreite

Analog zu der Spanungsdicke wird hiermit die Breite des abzutragenden Materials be-

schrieben.

Spanungsquerschnitt

Der Spanungsquerschnitt beschreibt die Schnittfläche des abzutragenden Materials.

Diese Fläche setzt sich aus der Spanungsdicke und der Spanungsbreite zusammen.

Spanungsgeometrie

Die Spanungsgeometrie beschreibt die Form des Spans, ohne Berücksichtigung der

auftretenden Wärmeenergie etc., die zu der Verformung des Spans führen.


Abbildung 1: Begriffe beim Prozess der Spanung

Durchdringungsrechnung

Eine Durchdringungsrechnung beschreibt die Berechnung von geometrischen Objek-

ten nach deren Durchdringung. Hierbei werden nur die geometrischen Größen wie Flä-

chen oder Volumen berücksichtigt und anhand dieser Informationen neue (resultieren-

de) Objekte berechnet. Man kann sich diesen Vorgang einfach vorstellen anhand eines

Objektes A (Werkzeug), welches in Objekt B (Werkstück) eindringt. Ein sinnvolles Er-

gebnis bei diesem Beispiel wäre ein neues Objekt C, welches die Schnittmenge der

beiden Objekte A und B beschreibt, sowie eine neues Objekt B‘, welches durch die

Differenz von Objekt B und C bestimmt wird (siehe Abbildung 2).

Abbildung 2: Beispiel einer Durchdringungsrechnung


Zeitkarte

Eine Zeitkarte beschreibt den Ist-Zustand der Geometriedaten zu einem fixen Zeit-

punkt. Zu diesem Zeitpunkt fallen diverse Daten (z.B. Simulationsergebnisse) an, die

einer Zeitkarte zugeordnet werden. Die Zeitkarte versteht sich dabei auch als konkreter

Zeitschritt und wird in der vorliegenden Arbeit als Synonym dafür verwendet.

2.2 Wälzfräsen

Das Wälzfräsen ist ein besonders wirtschaftliches Verfahren zur Fertigung von Ver-

zahnungen mit geometrisch bestimmter Schneide. Der schneckenförmige Wälzfräser

und das Werkstück wälzen während des Prozesses aufeinander ab, wie die beiden

Komponenten eines Schneckengetriebes. Unter einem Vorschub des Werkzeugs so-

wie der Rotation von Werkzeug und Werkstück werden die Späne abgehoben.

Die Geometrie des Wälzfräsers ist durch verschiedene Größen bestimmt. Hierzu gehö-

ren insbesondere die Gangzahl wie auch die Stollenzahl . Die einzelnen Stollen

sind an der Oberfläche der zylindrischen Grundform des Wälzfräsers angebracht. Die

einzelnen Schneidzähne sind zwischen den Stollen so versetzt, dass sie eine Spirale

um den Wälzfräser bilden. In Abbildung 3 sind es 16 Stollen und eine Spirale (Gang-

zahl 1) von Schneidzähnen, die sich über die Stollenlänge erstreckt. Wären es

zwei Spiralen von Schneidzähnen, so würde die Gangzahl 2 betragen. Als Span-

nuten werden die Freiräume zwischen den Stollen bezeichnet. Die Spanfläche ist die

Fläche der Schneide auf einem einzelnen Schneidzahn, welche für den eigentlichen

Materialabtrag verantwortlich ist.

Abbildung 3: Geometrische Kenngrößen eines Wälzfräsers ([Weigel], S. 35)


Zur Herstellung eines so genannten Zylinderrades wird eine zylindrische Scheide als

Werkstück verwendet. Hier sind durch die Wälzfräsmaschine sowie durch den Wälzfrä-

ser die zulässigen Dimensionen der Verzahnungsgeometrie bestimmt. Die Scheibe

wird mit einem Spannmittel fixiert und hat in der Maschine lediglich einen rotatorischen

Freiheitsgrad.

Es gibt verschiedene Wälzfräsverfahren, welche durch die sich überlagernden

rotatorischen und translatorischen Bewegungsabläufe definiert sind. Die translatorische

Komponente des Werkzeuges wird das Verfahren bestimmt. Es wird unterschieden

zwischen Axial-, Radial-Axial-, Tangential- und Diagonal-Wälzfräsen. Der Axialvor-

schub ist hier auf die Rotationsachse des Werkstückes (in Abbildung 6 Zylinderrad)

bezogen. Mit dem Radialvorschub wird der Vorschub des Werkzeugs in radialer

Richtung des Werkstückes beschrieben; dieser Vorschubweg wird auch als Tauchtiefe

bezeichnet. Der Tangentialvorschub hingegen beschreibt eine tangentiale Bewe-

gung entlang des Werkstückes parallel zur Rotationsachse des Wälzfräsers. Bei dem

Diagonalwälzfräsen findet eine Kombination aus Tangential- und Axialvorschub statt.

Die rotatorische Komponente ist in allen Varianten zwischen Werkzeug und Werkstück

gekoppelt. Abhängig von der gewünschten Zähnezahl des Zahnrades sowie etwaigen

Vorschüben ist die Rotation des Werkstückes durch die Rotation des Werkzeuges be-

stimmt. In der Industrie wird heute hauptsächlich das Axialwälzfräsen angewendet,

welches in Kapitel 2.2.1 beschrieben ist.

Weitere Kenngrößen beim Wälzfräsen sind der Modul , der Schrägungswinkel 2,

das angewendete Verfahren, Gleich- bzw. Gegenlauffräsen, und bei Schrägverzah-

nungen das gleichsinnige bzw. gegensinnige Wälzfräsen.

Schrägungswinkel

Die Rotationsachse des Wälzfräsers ist bei einer Geradverzahnung bereits um den

Steigungswinkel des Wälzfräsers geneigt. Der Schrägungswinkel 2 beschreibt die

zusätzliche Neigung der Rotationsachse um den gewünschten Schrägungswinkel der

Schrägverzahnung. In Abbildung 4 ist die Zusammensetzung des resultierenden Nei-

gungswinkels der Rotationsachse des Fräsers dargestellt (vgl. [Klocke 2008], S.

441).


Abbildung 4: Paarung Wälzfräser-Werkstück am Beispiel des Wälzfräsens ([Klocke

2008], S. 441)

Gleich- und Gegenlauffräsen

Bei dem Verfahren wird zwischen dem Gleich- und Gegenlauffräsen unterschieden. In

Abbildung 4 ist das häufig angewandte Gleichlauffräsen zu sehen. Beim Gegenlauffrä-

sen würde der Fräser in inverser axialer Richtung verfahren.

Gleich- und gegensinniges Wälzfräsen

Das gleich- und gegensinnige Wälzfräsen bezieht sich auf die Steigungsrichtung des

Wälzfräsers und des Zahnrades. Wenn die Steigungsrichtung des Wälzfräsers (rechts-

oder linkssteigend) identisch mit der Steigungsrichtung des Zahnrades ist, spricht man

von gleichsinnigem Wälzfräsen, ansonsten handelt es sich um gegensinniges Wälzfrä-

sen. Durch eine entsprechende Einstellung des Neigungswinkels kann man mit ei-

nem rechtssteigenden Wälzfräser ein linkssteigendes Zahnrad herstellen und umge-

kehrt.

Modul

„Der Modul ist ein Größenfaktor der Verzahnung“ ([Albers 2006], S. 398). Über diese Größe lassen sich weitere Kenngrößen berechnen. So bestimmt dieser Wert z.B. als ein Vielfaches der Kreiszahl den Abstand (Bogen) benachbarter Zähne.

Die durch das Wälzfräsen erzeugten Zahnradflanken sind in der Regel durch eine

Evolvente beschrieben. Durch diese spezielle Flankenform sind eine höhere Laufruhe

sowie eine geringere Stoßbelastung im Vergleich zu geraden Flanken möglich (vgl.

[Niemann 2003], S. 50).

Das Zusammenspiel der Geometrie von Werkzeug und Werkstück über die Prozess-

Kinematik resultiert in verschiedenen sog. Wälzstellungen. Eine Wälzstellung ist aus

Sicht des Werkstückes das Eintauchen und Austreten einer Schneide in die zu fräsen-

de Zahnlücke. Die Wälzstellungen werden durchnummeriert, beginnend bei der ersten

Schneide die Material abträgt. Dabei orientiert sich die Zählung an der mittleren Wälz-


stellung, welcher der Wert 0 zugewiesen wird. Alle Wälzstellungen davor sind negativ

und zählen in Richtung 0, analog zählen alle Wälzstellungen danach im positiven Be-

reich weiter.

Abbildung 5: Zusammenhang der Gangzahl und Spannuten mit den Wälzstellungen

([Obermeier 2006], S. 10)

In Abbildung 5 ist der Einfluss der Spannutenzahl (implizit auch der Stollenzahl) sowie

der Gangzahl dargestellt. Eine niedrige Gangzahl und eine hohe Spannutenzahl führen

zu einer hohen Anzahl von Schneiden im Eingriffsbereich und somit zu vielen Wälzstel-

lungen. Die Materialmenge, die pro Schneide abgetragen werden muss, ist also gerin-

ger. Dies hat wiederum eine geringere Belastung der Einzelschneide zur Folge.

Im Gegenzug dazu führen eine hohe Gangzahl und weniger Spannuten zwar zu einem

höheren Abtragsvolumen pro Zeit, aber auch zu einer höheren Belastung an den Ein-

zelschneiden. Bei einem mehrgängigen Wälzfräser ist nicht jeder Gang (Spirale der

Schneidzähne) an der Herstellung aller Zahnlücken beteiligt. Bei einer fortlaufenden

Nummerierung der Zahnlücken würde die Beteiligung der Gänge an den Zahnlücken

wie folgt aussehen:

Tabelle 1: Beteiligung der Gänge an Zahnlücken

ZL = Zahnlücken ZL 1. Gang ZL 2. Gang ZL 3. Gang

1 gängig 1,2,3,4,… - -

2 gängig 1,3,5,7,… 2,4,6,8,… -

3 gängig 1,4,7,10,… 2,5,8,11,… 3,6,9,12,…

Diese Verteilung gilt nur für mehr als eine Werkstückumdrehung, wenn Folgendes gilt:

Zähnezahl mod1 Gangzahl = 0

Ansonsten hat man nach jeder Werkstückumdrehung einen entsprechenden Versatz.

1 Modulo Operator.

2 gängig mit 14 Spannuten 1 gängig mit 24 Spannuten


(vgl. [Albers 2006], S. 384-423 u. [Grote 2007], S. 69 – S. 76 u. [Klocke 2008], S. 440

ff. u. [Gacka 2006], S. 292 ff.)

2.2.1 Axialwälzfräsen

Das Axialwälzfräsen ist die in der Industrie zurzeit am häufigsten eingesetzte Variante

des Wälzfräsens (vgl. [Grote 2007], S. 70). Abbildung 6 zeigt die Kinematik des Pro-

zesses, die sich durch die folgenden Eigenschaften auszeichnet:

Rotation des Zylinderrades

Kontinuierlicher axialer Vorschub des Wälzfräsers

Initialer radialer Vorschub des Wälzfräsers

Kein tangentialer Vorschub parallel zur Rotationsachse des Fräsers

Rotation der Wälzfräserachse

Neigung der Rotationsachse des Wälzfräsers

Der Wälzfräser fährt bei dieser Variante nur in axialer Richtung in das Werkstück. In

Abbildung 4 sind die Abschnitte (Einlauf, Vollschnitt und Auslauf) dieses Prozesses

eingezeichnet. Diese drei Bereiche werden zeitlich nacheinander durchfahren. Zu Be-

ginn berührt der Wälzfräser das Werkstück nur an der untersten Kante. Durch den

axialen Vorschub fährt der Wälzfräser immer weiter in das Werkstück hinein. Die

Schnittbogenlänge nimmt stetig zu und erreicht ihr Maximum mit dem Beginn des Voll-

schnittbereichs. In diesem Bereich bleibt die Schnittbogenlänge konstant bis der Aus-

laufbereich erreicht wird.

Wie man in Abbildung 6 erkennen kann, sind nicht alle Schneidzähne gleichzeitig im

Einsatz. Die Schneidzähne im mittleren Bereich des Wälzfräsers befinden sich im Ar-

beitsbereich des Wälzfräsers, andere befinden sich hingegen in den äußeren Berei-

chen des Wälzfräsers und sind nicht an der Zerspanung beteiligt. Um die Schneidzäh-

ne des Wälzfräsers möglichst gleichmäßig zu verschleißen, kann der Fräser zwischen

Wälzvorgängen in tangentialer Richtung durch sog. Shifting verschoben werden.


Abbildung 6: Axialwälzfräsen

2.2.2 Schlagzahnfräsen

Das Schlagzahnfräsen ist ein Analogieprozess, der den Prozess des Wälzfräsens mit

nur einem Schneidzahn nachstellt. Hierbei wird eine angepasste Kinematik verwendet,

um alle beim Wälzfräsen am Prozess beteiligten Schneidzähne abzufahren (vgl.

[Claudin 2009], S. 5152–5160 und [Bouzakis 2002], S. 42-51).

Dieser Prozess eignet sich besonders gut für Verschleißuntersuchungen, da hier ein

Schneidzahn alle Schnitte durchführt. Verschleiß tritt demnach viel eher ein. Im Ge-

genzug ist dieser Prozess, trotz eines identischen Endergebnisses, nicht für den pro-

duktiven bzw. industriellen Einsatz geeignet. Die Produktivität ist im Vergleich zum re-

gulären Wälzfräsen zu gering.

Die Abbildung 7 zeigt in Teil a anschaulich die einzelnen Komponenten, in Teil b sind

die Komponenten dieses Prozesses zusammen in Form Ihrer lokalen Koordinatensys-

teme dargestellt. Anhand dieser Koordinatensysteme sollen die sechs möglichen Frei-

heitsgrade beim Wälzfräsen veranschaulicht werden. Die Angaben in den Klammern

beziehen sich auf die Abbildung 7 Teil b:

Rotation des Werkstückes (1 rotiert um Z-Achse von 2)

Axialer Vorschub des Wälzfräsers (Translation zwischen 2 und 3 in Z-Richtung)

Radialer Vorschub des Wälzfräsers (Translation von 4 nach 3 in Y-Richtung)


Tangentialer Vorschub parallel zu der Rotationsachse des Fräsers (Translation

von 5 nach 6 in X- und Z-Richtung)

Neigung der Rotationsachse des Wälzfräsers (Neigung um die Y-Achse bei ei-

nem Mittelpunkt des Wälzfräsers mit Y=0)

Rotation der Wälzfräserachse (Rotation um die X-Achse von 6)

Der Prozess des Schlagzahnfräsens ist dagegen durch die folgenden Komponenten

definiert.

Rotation des Werkstückes (1 rotiert um Z-Achse von 2)

Rotation der Wälzfräserachse (Rotation um die X-Achse von 6)

Neigung der Rotationsachse des Wälzfräsers (Neigung um die Y-Achse bei Mit-

telpunkt des Wälzfräsers Y=0)

Kein axialer Vorschub während eines Durchlaufs

Kein radialer Vorschub

Kontinuierlicher tangentialer Vorschub auf der Rotationsachse des Fräsers (von

5 nach 6 in X-Richtung) während eines Durchlaufs

Die beteiligten Freiheitsgrade sind in Tabelle 2 für das Schlagzahnfräsen, im Vergleich

zum Axialwälzfräsen, dargestellt.

Tabelle 2: Freiheitsgrade beim Axialwälzfräsen und Schlagzahnfräsen

Freiheitsgrad Beschreibung Axialwälzfräsen Schlagzahnfräsen

1 Rotation des Werk-

stücks

Ja Ja

2 Rotation des Werke-

zeugs

Ja Ja

3 Axialer Vorschub des

Werkzeugs

Ja: Kontinuierlich Ja: Diskontinuier-

lich nach jeder

Zeile

4 Radialer Vorschub des

Werkezeugs

Nein: Nur initial zur

Einstellung der

Tauchtiefe

Nein: Nur initial zur

Einstellung der

Tauchtiefe

5 Tangentialer Vorschub

des Werkzeugs parallel

zur Rotationsachse

des Werkzeugs

Nein Ja

6 Neigung der Rotation-

sachse des Werkzeugs

Ja Ja


Nachdem ein Durchlauf abgeschlossen ist, findet ein Rückhub in tangentialer Richtung

statt. Anschließend wird ein diskontinuierlicher axialer Vorschub ausgeführt. Schließlich

beginnt ein neuer Durchgang mit kontinuierlichem Vorschub in tangentialer Richtung.

Dieser Vorgang wird so oft wiederholt, bis der axiale Vorschubweg erreicht und der

letzte Durchgang abgeschlossen ist. Mit diesem Vorgehen werden zeilenweise alle

Wälzstellungen des Axialwälzfräsens nachgestellt. Die Stollenzahl und damit implizit

die Anzahl der Schneiden, die am Fräsprozess beteiligt sind, werden über den tangen-

tialen Vorschub realisiert. Für die Gangzahl ist neben dem tangentialen Vorschub eine

angepasste synchronisierte Rotation zwischen Werkzeug und Werkstück entschei-

dend. Dabei kann entweder jeder Gang einzeln mit einem Schlagzahn durchgeführt

werden. Dadurch wird für jeden Gang der gesamte Prozess wiederholt. Alternativ kann

die Anzahl der Schlagzähne auf die Zahl der Gänge erhöht werden.

Um den tangentialen Vorschub in Millimeter pro Werkstück-Umdrehung zu berechnen,

kann die folgende Formel verwendet werden. Diese Formel stammt aus dem Fräspro-

gramm für das Schlagzahnfräsen einer Gleason-Pfauter GP 130 Wälzfräsmaschine.

∙ m ∙ z

cos ∙ i

In diese Formel gehen die folgenden Kenngrößen ein:

der Modul m

die Gangzahl z

der Steigungswinkel

die Stollen- bzw. Spannutenzahl i

(vgl. dazu Kapitel 2.2 Wälzfräsen)


Abbildung 7: Schlagzahnfräsen ([Bouzakis 2008], S. 680)

2.2.3 Softwareunterstützung für das Schlagzahnfräsen

Wie die vorigen Kapitel gezeigt haben, ist der Prozess des Wälzfräsens extrem inho-

mogen. Jede Schneide trägt in ihrer Wälzstellung einen von allen anderen Wälzstel-

lungen abweichenden Span ab. Die Schneidenbelastung stellt sich nicht anhand von

Parametern wie Schnitttiefe, Vorschub und Schnittgeschwindigkeit ein, sondern hängt

zusätzlich noch von der Geometrie der Schneide und des Werkstücks ab.

Um die für den realen Prozess relevanten Größen mit Hilfe einer Computeranwendung

zu ermitteln, gibt es verschiedene Ansätze.

Der Fokus dieser Arbeit ist dabei auf die Durchdringungsrechnung gerichtet, ohne

Rücksicht auf weitere Faktoren zu nehmen, die bei dem realen Prozess an der Ma-

schine eine Rolle spielen. Dies könnten z.B. Kräfte oder Materialeigenschaften sein.

Um solche Faktoren zu berücksichtigen, eignen sich beispielsweise FEM2-

Simulationsprogramme. Es können aber auch einige Aussagen über einen Fertigungs-

2 FEM = Finite Elemente Methode (s. Glossar)


prozess getroffen werden, ohne diese Details zu berücksichtigen. So kann man bereits

Rückschlüsse auf die Einzelschneidenbelastung aus der abgetragenen Materialmenge

pro Schnitt ziehen. Intuitiv ist es verständlich, dass je mehr Material pro Schnitt abge-

tragen werden muss, auch umso mehr Kräfte und thermische Belastungen am Werk-

zeug auftreten.

Die Arbeit orientiert sich an der Dissertation von Gerd Sulzer [Sulzer 1973], welche

sich bereits mit diesem Thema befasst hat. Im Rahmen der Dissertation wurde ein

Programm (FRS) für damalige Rechner entwickelt, welches mit diversen Einschrän-

kungen in Bezug auf Genauigkeit, Geschwindigkeit und Visualisierungsmöglichkeiten

auskommen musste. Einige der bestehenden Lösungen, die in Kapitel 2.3 folgen,

nehmen die Arbeit Sulzers ebenfalls als Basis für die eigenen Entwicklungen. Mit den

Möglichkeiten der modernen Hochprogrammiersprachen sowie den heute verfügbaren

Rechnern soll im Rahmen dieser Arbeit untersucht werden, wie eine Durchdringungs-

rechnung abgebildet werden kann.

Die Software soll also dabei helfen, für die komplexe Kinematik des Prozesses die ein-

zelnen Schnitte zu simulieren, welche schließlich das fertige Werkstück sowie die da-

bei entstandenen Spanungsquerschnitte bestimmen. Dabei ist sukzessive vorzugehen

und für jeden neu zu berechnenden Schnitt sind die resultierenden Werkstückdaten

des vorigen Schnittes zu verwenden.

2.3 Bestehende Lösungen

Ergänzend zu den üblichen experimentellen Untersuchungen an der Maschine, spielt

die Simulation eine zunehmend wichtige Rolle in der Fertigungstechnik. Gerade im

Bereich der Prozessoptimierung sind Simulationen ein geeignetes Mittel, um Prozesse

gefahrlos und kostengünstig zu testen.

Es gibt viele Software-Lösungen, die sich mit dem Simulieren von Fräsprozessen so-

wie deren Ergebnissen befassen. Schränkt man die Suche jedoch auf Produkte ein, die

sich nur mit dem Wälzfräsen befassen, so reduziert sich deren Anzahl. Sollen es dann

auch zusätzlich noch Software-Lösungen sein, die nicht nur das finale Werkstück simu-

lieren können, sondern zusätzlich die anfallenden Spanungsquerschnitte ermitteln,

verbleiben nur sehr wenige Lösungen. Dieses Kapitel soll einen Überblick über diese

Lösungen geben, die genau diese Anforderungen erfüllen. Weiter möchte ich darstel-

len, wie sich der zu entwickelnde Software-Prototyp von diesen Lösungen abgrenzt.

2.3.1 FRS

FRS ist die erste, dem Autor bekannte, Umsetzung einer Durchdringungsrechnung auf

einem Digitalrechner. Gerd Sulzer hat dieses Programm im Rahmen seiner Dissertati-

onsschrift [Sulzer 1973] entwickelt. Das Programm wurde für einen damaligen Groß-

rechner (CDC 6400) entwickelt. Dieser war mit einer CPU ausgestattet, die eine unge-


fähre Rechenleitung von 1-10 MIPS (je nach Rechenoperation) bei ca. 10 Mhz erreich-

te (vgl. [Sulzer 1973], S. 43 und [CDC6000 2011]).

Funktionalität von FRS:


Ermittlung von Spanungsquerschnitten sowie der Spanungsgeometrien

Ausgabe der Simulationsergebnisse auf einem Plotter (vgl. [Sulzer 1973], S. 42

und S. 47)

Der Ansatz für die Umsetzung der Kinematik in FRS ist in Kapitel 2.4.2 beschrieben.

2.3.2 SPARTApro

SPARTApro ist eine Software-Lösung, welche am WZL der RWTH Aachen entstanden

ist. Die Software steht ausschließlich dem WZL-Getriebekreis, einer Kollaboration eini-

ger Industriefirmen mit dem WZL (vgl. [Gacka 2006], S. 267), zur Verfügung. Aus die-

sem Grund kann der Funktionsumfang nur anhand der Informationen der Website

[SPARTApro 2010], eines Werbeflyers sowie ([Gacka 2006], S. 312f.) beschrieben

werden.

Funktionalität von SPARTApro:

Auslegung von Werkzeugvarianten

Auslegung von Fräsprozessen


Ermittlung von Spanungsquerschnitten sowie der Spanungsgeometrien

Bestimmung dynamischer Eingriffsverhältnisse zwischen Wälzfräser und Werk-

stück

Unterstützung von Ein- und Mehrschnittstrategien


Abbildung 8: SPARTApro [SPARTApro 2010]

2.3.3 FRS/MAT

FRS/MAT ist an der Aristoteles Universität Griechenland entstanden. Hierbei handelt

es sich um ein in MATLAB entwickeltes Programm, welches die Durchdringungsrech-

nung durchführt und die Daten dann an eine CAD-Software übergibt. In der CAD-

Software wird dann die Erzeugung des Netzes für die 3D-Objekte durchgeführt. Aus

den Punktkoordinaten der FRS/MAT-Ergebnisse werden so 3D-Objekte. Diese dienen

dann als Eingabe für die FEM-Software (Deform 3D), mit der dann weitere Untersu-

chungen durchgeführt werden können (vgl. [Bouzakis 2008], S. 676-696).

Funktionalität von FRS/MAT:

Durchdringungssimulation

Bestimmung der Spanungsgeometrien

FEM-Simulationen


Abbildung 9: FRS/MAT ([Bouzakis 2008], S. 679)

2.3.4 HOB3D

Hob3D ist eine Softwarelösung, die an der technischen Universität Kreta entstanden

ist. Es ist in Visual Basic implementiert und nutzt ein nicht näher genanntes kommerzi-

elles CAD-Programm zur Modellierung und Visualisierung (vgl. [Dimitrou 2009], S. 347-

357 und [Vasilis 2007], S. 911-918).

Funktionalität von HOB3D:

Werkzeuggeometrie einstellbar, Bezugsprofil wird errechnet


Visualisierung der Ergebnisse

Bestimmt die Spanungsgeometrien anhand von Volumensubtraktion


Abbildung 10: HOB3D ([Vasilis 2007], S. 916)

2.3.5 Hobicam

Hobicam ist eine Software-Lösung, welche von der Firma MHAC Technologies (Ecully,

Frankreich) entwickelt und vertrieben wird. Bei Hobicam handelt es sich nicht um ein

eigenständiges Programm, sondern um ein Erweiterungsmodul für das CAD-

Programm SolidWorks. Das Programm wurde entwickelt, um die Spanungsgeometrien,

welche beim Wälzfräsen in dem realen Prozess verformt anfallen, zu ermitteln. Hierbei

geht es darum, genau wie bei den anderen Lösungen, eine Quantifizierung der Spa-

nungsquerschnitte durchzuführen ([Hobicam 2010], S. 14-19).

Funktionsumfang von Hobicam:

Werkzeuggeometrie einstellbar


Visualisierung der Ergebnisse

Bestimmt die Spanungsgeometrien


Abbildung 11: SolidWorks-Modul Hobicam ([Hobicam 2010], S. 14)

2.3.6 Abgrenzung

Die hier vorgestellten Lösungen sind weder frei noch kommerziell verfügbar. Bis auf

FRS und SPARTApro stellen die verbleibenden drei kein eigenständiges Programm

dar, sondern sind entweder ein Modul für ein anderes kommerzielles Softwareprodukt

oder setzen dieses in Form einer Simulationsprozesskette voraus. Detaillierte Informa-

tionen der vorgestellten Lösungen, wie z.B. die verwendeten Software-Algorithmen,

stehen ebenfalls nicht zu Verfügung.

Der im Rahmen dieser Arbeit zu entwickelnde Software-Prototyp soll dagegen ein ei-

genständiges Programm sein, ohne dabei Abhängigkeiten zu anderen Softwareproduk-

ten aufzuweisen. Darüber hinaus soll er, ganz im Sinne eines experimentellen Soft-

ware-Prototyps, erweiterbar sein. Er soll dazu dienen, auf allen Ebenen der Applikation

Änderungen und Variationen zu ermöglichen. Dies sind insbesondere:

Die Diskretisierung sowie das Geometriemodell

Visualisierung von Prozessen sowie der Ergebnisse

Algorithmen für einzelne Teile der Simulation (Kinematik, Schnittberechnung)

Dateiformate (Import, Export)

Die Benutzungsschnittstelle

Erweiterung um weitere Zerspanverfahren und Simulationsmodelle


2.4 Datenmodelle, Formeln und Algorithmen

2.4.1 Diskretisierung

Für die Durchdringungsrechnung beim Schlagzahnfräsen ist der Arbeitsbereich des

Wälzfräsers am Werkstück interessant. Hier sollen für jede Zeitkarte der Simulation die

Werkstückkontur und analog dazu die abgetragenen Spanungsquerschnitte beschrie-

ben werden können. Die Ortsinformationen in diesem Bereich sollten so fein wie mög-

lich aufgelöst werden können, um Fehler, welcher bei Simulationen mit einer Diskreti-

sierung nicht zu vermeiden sind, zu minimieren. Im Folgenden werden einige

Diskretisierungsmodelle vorgestellt, dabei diskretisieren einige das komplette Volumen,

andere beschäftigen sich dagegen nur mit der Diskretisierung der Oberfläche bzw. der

Randzone.

Dexel-Modell

Das Dexel-Modell, das oft auch „Nagelbrettmodell“ genannt wird, bildet das komplette

Volumen eines Objektes ab. Das Modell besteht aus Stabelementen (Nägeln), die nur

durch Ihre Startkoordinaten sowie eine Längeninformation abgebildet sind (vgl. [Hou

2003], S. 16 f.). Das Dexel-Modell gibt es in unterschiedlichen Ausprägungen. So gibt

es z.B. das einfache Dexel-Modell, bei dem die Stabelemente parallel zueinander in

einer Dimension abgebildet werden. Dieses einfache Modell ist besonders dann gut

geeignet, wenn der Materialabtrag in der Simulation maßgeblich nur aus einer Rich-

tung stattfindet. Dies kommt z.B. häufig beim Schleifen von planen Oberflächen aber

auch beim Drei-Achs-Fräsen vor. Das Dexel-Modell lässt sich aber auch durch Hinzu-

fügen von Dexeln in weiteren Dimensionen erweitern. Somit kann der Materialabtrag in

alle Richtungen mit identischer Genauigkeit untersucht werden. Das Modell ist darüber

hinaus in der Lage, eine Unterbrechung eines Dexels durch das Abtragen von Material,

in zwei neue Dexel zu überführen.

Voxel-Modell

Beim Voxel-Modell wird das Objekt in Volumenpixeln aufgelöst. Dies funktioniert ana-

log zu Pixeln bei 2D-Bildern, mit dem Unterschied, dass hier die dritte Dimension eben-

falls abgebildet wird (vgl. [Klawonn 2009, S. 157 f.]). Dieses Modell kommt häufig bei

bildgebenden Verfahren, z.B. in der Medizintechnik, zum Einsatz. Hier geht es darum,

gemessene Werte zu visualisieren und dabei nicht nur die Hülle, sondern das Volumen

als Ganzes zu beschreiben. Durch die komplette Abbildung des Objektes ergibt sich

schnell eine hohe Anzahl von Voxeln. Die Anzahl der Voxel erhöht sich demnach um

den Faktor 8 bei der Verdopplung der Auflösung (23).


Octree-Modell

Dieses Modell liefert einen Ansatz, die hohe Anzahl an Objekten des Voxel-Modells zu

verringern. Hierbei werden Voxel in acht Teile zerlegt, die selber wieder ein acht Voxel

zerlegt sein können. Dies kann in einer Baumstruktur beliebig fortgeführt werden (vgl.

[Klawonn 2009] S. 158 f. und [Agoston 2005a] S. 205). Dieses Modell bildet das kom-

plette Volumen ab und ermöglicht dabei an ausgewählten Stellen eine feinere lokale

Auflösung.

Polygonlinienmodell

Das Polygonlinienmodell ist ein Punkte-Modell, welches in unterschiedlichen Ausprä-

gungen eingesetzt werden kann. Das eigentliche Polygon wird dabei durch Kanten

zwischen den einzelnen Punkten gebildet. Mehrere Kanten hintereinander beschreiben

einen Polygonzug. Ist der Polygonzug geschlossen und verbindet den ersten Punkt mit

dem letzten, so bildet er ein Polygon (vgl. [Klawonn 2009], S. 13). Hier soll es als 2D-

Randzonenmodell vorgestellt werden. Dabei werden dreidimensionale Objekte durch

Polygonzüge in zweidimensionalen Ebenen beschrieben. Durch eine Extrusion der

Polygone lassen sich damit dreidimensionale Objekte beschreiben (vgl. [Extrusion

2011]). Der Abstand zwischen diesen Ebenen sowie der Abstand der einzelnen Punkte

der Polygonzüge sind hierbei die entscheidenden Diskretisierungsgrößen. Dieser An-

satz ermöglicht es, die Auflösung innerhalb eines Polygonzugs zu variieren. Für einen

Schnittalgorithmus bedeutet dies, dass zwei Punkte einen beliebigen Abstand haben

können. Damit erhöht sich zwar die Anzahl der zu untersuchenden Objekte, nicht aber

deren geometrische Form. Es handelt sich weiterhin um Segmente auf einer Geraden.

Somit ermöglicht es dieser Ansatz bei einer Durchdringungsrechnung, den Bereich des

Werkstücks, an dem das Material abgetragen wird, feiner aufzulösen. Darüber hinaus

lässt sich der Rechenaufwand als gering einschätzen, da bei jeder Zeitkarte nur

∙ ∙ Überschneidungen von Linien untersucht werden müssen. Wobei Anzahl

der Polygonzüge der Schneide, Anzahl der Polygonzüge des Werkstücks und

Anzahl der zu untersuchenden 2D-Schichten sind. Bei einem konkreten Schnitt-

algorithmus kann diese Einschätzung, aufgrund der entsprechenden Umsetzung, ab-

weichen.

Weitere Modelle

Neben den genannten Diskretisierungsvarianten, gibt es noch weitere Modelle. Dazu

gehören u. A. das CSG-Modell (vgl. [Klawonn 2009], S. 159 ff. und [Agoston 2005a], S.

167-171) sowie das b-rep-Modell (vgl. [Agoston 2005a], S. 166 f. und [Brep 2010]).

Bei der Anwendung der FEM-Methode findet ebenfalls eine Diskretisierung statt (vgl.

[Klein 2010], S. 307). Der Ansatz FEM-Methode sieht vor, dass man jedes Element mit

Eigenschaften versehen kann, um dann Einwirkungen von außen auf das Modell un-


tersuchen zu können. Dabei wird mit einem Gleichungssystem das Ergebnis berech-

net. Angewendet wird dies häufig für die Berechnung von Verformungen und Span-

nungen, welche durch physikalische Kräfte ausgelöst werden. Für die Durchdringungs-

rechnung wäre hier in erster Linie der Diskretisierungsansatz interessant. Es wäre bei

diesem Modell möglich, das Werkstück im Arbeitsbereich des Wälzfräsers besonders

fein aufzulösen. Der Aufwand bei der Diskretisierung sowie bei der Durchdringungs-

rechnung steigt hier jedoch enorm, da jedes Element eine andere Form haben kann

und mit jedem weiteren Element auf Überschneidung untersucht werden muss.

2.4.2 Mathematische Beschreibung der Kinematik beim Wälzfräsen

Das folgende Kapitel beschreibt die Kinematik aus mathematischer Sicht nach ([Sulzer

1973], S. 28-33). Anzumerken ist, dass dabei die Werkzeugschneide in dem Koordina-

tensystem der jeweiligen Zahnlücke beschrieben wird.

Abbildung 12: Koordinatensystem ([Sulzer 1973], S. 29)

System 1 = Werkradfestes System (Zahnlücke)

System 6 = Koordinatensystem des Fräsers (Schneide)

Punkt in System 1 = X1

Punkt in System 6 = X6

Fragestellung: Wie sind die Koordinaten von einem Punkt/Vektor aus System 6 in Sys-

tem 1?

Nach [Sulzer 1973] gilt:

X1 = X6 · T16 + C16

mit

T16 = T12 · T23 · T34 · T45 · T56


und

C16 = C56 · T15 + C45 · T14 + C34 · T13 + C23 · T12 + C12

T = Drehmatrix T‘ = inverse Drehmatrix

Tab = Drehmatrix von System a nach System b; Rotation um nur eine Achse

Tba = Tab‘ = inverse Drehmatrix

C = Translationsmatrix

Drehmatrizen und deren Inversen:

Rotation um X-Achse:

T = 1 0 000

T‘ = 1 0 000

Rotation um Y-Achse:

T = 0

0 1 00

T‘ = 0

0 1 00

Rotation um Z-Achse:

T = 00

0 0 1 T‘ =

00

0 0 1

System 1 -> System 2

Schrägungswinkel W12 bei Normalschnittberechnung

Drehung um die Z-Achse um den Winkel W12 und keine Verschiebung C12

T12 = 12 12 012 12 0

0 0 1 T12‘ = T21 =

12 12 012 12 0

0 0 1

C12 = 000


Drehbewegung W23 des Werkrades


Drehung um die Z-Achse um den Winkel W23 und keine Verschiebung C23, so-

fern Verschiebung in C45

T23 = 23 23 023 23 0

0 0 1 T23‘ = T32 =

23 23 023 23 0

0 0 1

C23 = 000


Radialvorschub C34 des Fräsers

Keine Drehung , Verschiebung C34 in Y-Richtung

T34 = 1

C34 = 0

0


Schwenkwinkel bzw. Fräsersteigungswinkel W45 und Axial- bzw. Schrägvor-

schub

Drehung um die Y-Achse um den Winkel W45 und Verschiebung C45, sofern kei-

ne Verschiebung in C23

T45 = 45 0 45

0 1 045 0 45

T45‘ = T54 =45 0 45

0 1 0 45 0 45

C45 = 00


Fräserdrehung W56 und Tangentialvorschub C56

Drehung um die X-Achse und Verschiebung in X-Richtung

T56 = 1 0 00 56 560 56 56

T56‘ = T65 = 1 0 00 56 560 56 56


C56 = 00

T13 = T23 · T12

T14 = T34 · T23 · T12

T15 = T45 · T34 · T23 · T12

X1 = X6 · T16 + C16

mit

T16 = T12 · T23 · T34 · T45 · T56

und

C16 = C56 · T15 + C45 · T14 + C34 · T13 + C23 · T12 + C12

X1 = X6 · T16 + C16

mit

T16 = 12 12 012 12 0

0 0 1 ·

23 23 023 23 0

0 0 1· 1·

45 0 450 1 0

45 0 45· 1 0 00 56 560 56 56

und

C16 = 00

· T15 + 00

· T14 + 0

0· T13 +

000· T12 +

000

T13 = 23 23 023 23 0

0 0 1·

12 12 012 12 0

0 0 1

T14 = 1 · 23 23 023 23 0

0 0 1·

12 12 012 12 0

0 0 1

T15 = 45 0 45

0 1 045 0 45

· 1 · 23 23 023 23 0

0 0 1·

12 12 012 12 0

0 0 1


2.4.3 Polygonschnitt

Um den Schnitt von zwei überschneidungsfreien3 Polygonen zu berechnen, stehen

verschiedene Algorithmen zur Verfügung. In [Sulzer 1973] wird hierfür kein konkreter

Algorithmus genannt. Die im Folgenden beschriebenen Algorithmen waren zu dieser

Zeit allerdings auch noch nicht publiziert. Der früheste Vertreter war der Sutherland-

Hodgman-Algorithmus, welcher 1974 definiert wurde (vgl. [Agoston 2005a], S. 84).

Sutherland-Hodgman

Weiler-Atherton

Liang-Barsky

Maillot

Vatti

Greiner-Hormann

Im Folgenden wird der Weiler-Atherton-Algorithmus vorgestellt. Dieser Algorithmus

zeichnet sich dadurch aus, dass er allgemeine, überschneidungsfreie Polygone

schneiden kann. Dabei kann sowohl die Schnittmenge als auch die Differenz von zwei

Polygonen berechnet werden. Darüber hinaus erzeugt er keine zusätzlichen Kanten

bei dem Polygonschnitt, wie z.B. der Sutherland-Hodgman-Algorithmus. Der Algorith-

mus ist leicht zu verstehen und zu implementieren. Für detaillierte Informationen zu

allen oben genannten Algorithmen vergleiche ([Agoston 2005a], S. 84-109).

Weiler-Atherton-Algorithmus

Dieser Algorithmus wurde zuerst in ([Weiler 1977], S. 217ff.) beschrieben und als Al-

ternative für den Sutherland-Hodgman-Algorithmus entwickelt. Ziel war es, die zusätz-

lichen Kanten außerhalb des eigentlichen Polygons, die bei diesem Algorithmus ent-

stehen können, zu beseitigen.

3 Überschneidungsfrei bedeutet, dass sich der Polygonzug nicht selbst schneiden darf.


Abbildung 13: Polygonschnitt

Ein einfaches Beispiel zeigt die Abbildung 13. Hier überlappen sich die beiden Polygo-

ne A und B. Eine notwendige Grundvoraussetzung für den Weiler-Atherton-

Algorithmus ist, dass beide Polygone eine identische Richtung haben müssen; der

konkrete Algorithmus geht hierbei von Polygonen im Uhrzeigersinn aus (vgl. [Weiler

1977], S. 217). Der erste Schritt im Weiler-Atherton Algorithmus ist, alle Kanten von

Polygon A mit den Kanten von Polygon B zu schneiden. Hier kann einfach anhand der

Geradengleichungen überprüft werden, ob sich die beiden Geraden schneiden. Da sich

zwei nicht parallele Geraden immer schneiden, muss noch überprüft werden, ob der

Schnittpunkt auf den Geraden-Segmenten (Polygonkanten) liegt. Gefundene Schnitt-

punkte werden nun in eine von zwei Merklisten eingetragen. Eine Merkliste ist dabei für

die Eintrittsschnittpunkte, die andere für die Austrittsschnittpunkte bestimmt. Um wel-

chen dieser beiden Fälle es sich handelt, lässt sich anhand der Richtung und der Wahl

des schneidenden Polygons treffen.

In Abbildung 13 ist Polygon A das schneidende Polygon, mit dem das Polygon B ge-

schnitten wird. Somit ist der obere Schnittpunkt in Teilbild 2 ein Eintrittsschnittpunkt

und der untere entsprechend ein Austrittsschnittpunkt. Schnittpunkte treten immer

paarweise auf, so dass am Ende die beiden Merklisten gleich groß sind. Die Schnitt-

punkte werden nun in die beiden Polygonlisten als neue Knotenpunkte eingefügt. Da-

bei werden sie als Schnittpunkte markiert und zwischen den beiden Polygonlinien ver-

knüpft, so dass ein Wechseln zwischen den Konturen möglich ist.


In Teilbild 3 ist die Schnittmenge von Polygon A und B als Polygon C hervorgehoben.

Teilbild 4 zeigt dabei das neue Polygon B‘, welches durch die Differenz von Polygon A

und B entstanden ist. Diese beiden Polygone können durch den Weiler-Atherton-

Algorithmus einfach gebildet werden, indem man folgende Schritte durchführt:

Schnittmenge (Polygon C):

1. Entferne einen Schnittpunkt aus der Liste der Austrittsschnittpunkte und wähle

diesen als Startpunkt.

2. Folge dem geschnittenen Polygon (B) bis zum nächsten Eintrittsschnittpunkt

auf dem Polygon und entferne diesen aus der Merkliste.

3. Wechsle auf das schneidende Polygon (A).

4. Folge dem schneidenden Polygon (A) bis zum nächsten Schnittpunkt und

gleichzeitig dem Startpunkt dieses Durchlaufs.

5. Wechsle auf das geschnittene Polygon (B).

6. Ein (Teil-)Polygon der Schnittmenge (in dem Beispiel Polygon C) ist nun voll-

ständig.

7. Die Schritte 1-6 sind so oft zu wiederholen, bis keine Austrittsschnittpunkte

mehr in der Merkliste vorhanden sind.

Differenz (Polygon B‘):

1. Entferne einen Schnittpunkt aus der Liste der Eintrittsschnittpunkte und wähle

diesen als Startpunkt.

2. Folge dem geschnittenen Polygon (B) bis zum nächsten Austrittsschnittpunkt

auf Polygon und entferne diesen aus der Merkliste.

3. Wechsle auf das schneidende Polygon (A).

4. Folge dem schneidenden Polygon (A) in inverser Richtung bis zum nächsten

Eintrittsschnittpunkt.

5. Wenn es sich bei diesem Eintrittsschnittpunkt um den Ausgangsschnittpunkt

handelt, ist das Polygon B‘ vollständig. Ansonsten wiederhole Schritt 1-5, bis

der Ausgangspunkt erreicht ist.

Dies ist eine vereinfachte Darstellung des Weiler-Atherton-Algorithmus, welcher durch

weitere Regeln auch Polygone mit Enklaven (Löchern) unterstützt (vgl. [Weiler 1977],

S. 214-222 und [Agoston 2005a], S. 85-86).

2.4.4 Flächenberechnung von Polygonen

Für die Flächenberechnung von überschneidungsfreien Polygonen eignet sich die

Gauß‘sche Trapezformel. Aus den Koordinaten der Eckpunkte eines Polygons kann

die Fläche berechnet werden.

2 ∙ A ∑ y y ∙ x x


Hierzu werden die einzelnen Trapezflächen unter den Polygonkanten addiert. Polygon-

kanten in positiver X-Richtung erzeugen Flächen mit positivem Vorzeichen (blau) und

Polygonkanten in negativer X-Richtung erzeugen Flächen mit negativem Vorzeichen

(rot) (vgl. Abbildung 14). Diese Formel gilt nur dann, wenn sich alle Koordinaten des

Polygons im selben Quadranten des Koordinatensystems befinden (vgl. [Bronstein

1993], S. 139 und [Gauß 2011]).

Abbildung 14: Trapezflächen eines Polygons

2.5 Fazit

Es existieren bereits einige Lösungen, um Durchdringungsrechnungen für das Wälz-

fräsen durchzuführen. Leider ist keine dieser Software-Lösungen verfügbar und kann

somit auch nicht in dieser Arbeit näher untersucht werden. Darüber hinaus soll die be-

nötigte Software auch erweiterbar sein, so dass weitere Modelle und Verfahren abge-

bildet werden können. Hierfür müsste nicht nur das Programm, sondern auch dessen

Quellcode verfügbar sein. Die Entwicklung eines Software-Prototyps ist damit erforder-

lich. Die Dissertation von Gerd Sulzer aus dem Jahr 1973 beschäftigt sich bereits mit

dieser Thematik. Im Vergleich zu den heutigen technischen Möglichkeiten waren diese

1973 geradezu bescheiden. Dennoch sind die Ansätze von Sulzer immer noch geeig-

net, Durchdringungsrechnungen durchzuführen. Für einige Teil-Probleme existieren

inzwischen Standard-Algorithmen. Die Geschwindigkeiten sowie Kapazitäten moderner

Rechner erlauben einen deutlich höheren Detaillierungsgrad der Simulation.

Zielsetzung und Vorgehensweise 37

3 Zielsetzung und Vorgehensweise

3.1 Zielsetzung

Nach der Analyse bestehender Systeme sowie der Betrachtung der notwendigen

Grundlagen wird im Folgenden das Ziel der Arbeit konkretisiert. Nachdem die beste-

henden Lösungen nicht verfügbar sind, ist im Rahmen dieser Arbeit ein experimenteller

Software-Prototyp zu entwickeln. Für die Umsetzung dieses Vorhabens ist eine geeig-

nete Entwicklungsumgebung auszuwählen. Mit diesem Prototyp sollen Durchdrin-

gungsrechnungen durchgeführt werden. Das Schlagzahnfräsen als Analogieprozess

des Axialwälzfräsens ist hierbei exemplarisch umzusetzen. Dabei sollen auf Basis der

Durchdringungsrechnung sowohl die Spanungsquerschnitte als auch die Oberflächen-

topographien zerspanter Werkstücke ermittelt werden können. Das Programm soll da-

bei modular aufgebaut werden, um nachträglich weitere Zerspanverfahren realisieren

zu können.

3.2 Vorgehensweise

Die Dissertation von Gerd Sulzer [Sulzer 1973] beschäftigt sich mit der Abbildung des

Wälzfräsens in einem Computerprogramm und wird als Basis für die Entwicklung des

eigenen Prototyps herangezogen. Für die Umsetzung des Prototyps werden Anforde-

rungen formuliert und in dem anschließenden Systementwurf konkrete Modelle und

Algorithmen für die Implementierung ausgewählt. Die Implementierung wird dabei in

angemessener Form dokumentiert. Anschließend wird die Funktionsfähigkeit anhand

exemplarischer Rechnungen dargestellt sowie eine Bewertung der Ergebnisse durch-

geführt.

3.3 Vereinfachter Programmablauf

Zur Veranschaulichung der wesentlichen Abläufe in der Durchdringungsrechnung wird

diese in Abbildung 15 in einem Ablaufdiagramm dargestellt.


Abbildung 15: Ablaufdiagramm der Durchdringungsrechnung (Schlagzahnfräsen)


3.3.1 Dateneingabe

Das Programm erhebt vor der Durchführung der Durchdringungsrechnung alle not-

wendigen Parameter. Hierzu kann der Benutzer über eine geeignete Benutzungsober-

fläche Parameter wie Geometriedaten für Werkzeug und Werkstück sowie Vorschübe,

Geschwindigkeiten und Diskretisierungsauflösungen festlegen. Das Programm

diskretisiert die Geometrie sowie die Zeitachse für die einzelnen Simulationsschritte.

3.3.2 Simulation

Der eigentliche Start der Simulation wird ebenfalls über die Benutzungsoberfläche

ausgelöst. Der Ablauf der Durchdringungsrechnung ist durch zwei Schleifen gekenn-

zeichnet (vgl. Abbildung 15). Die äußere Wiederholungsschleife repräsentiert den dis-

kontinuierlichen Axialvorschub beim Schlagzahnfräsen (vgl. Kapitel 2.2.2). Die Schleife

wiederholt das Fräsen eines Durchlaufes in tangentialer Richtung bis das axiale Vor-

schubende erreicht ist, also alle Zeilen gefräst sind. Die innere Schleife läuft solange,

bis das tangentiale Vorschubende eines einzelnen Durchlaufes erreicht ist. Innerhalb

dieser Schleife finden die synchronisierte Kinematikberechnung von Werkzeug und

Werkstück sowie die eigentliche Durchdringungsrechnung statt. Hierzu wird für jede

Zeitkarte die Position des Werkzeugs aufgezeichnet und nach einer Werkzeugumdre-

hung überprüft, ob das Werkzeug dabei das Werkstück durchdrungen hat. Wenn dies

der Fall ist, wird mit einem geeigneten Schnittalgorithmus der Spanungsquerschnitt

bestimmt sowie die neue Werkstückgeometrie. Dieser Vorgang wiederholt sich für jede

Werkzeugumdrehung, bis das tangentiale Vorschubende erreicht ist.

3.3.3 Datenausgabe

Die Datenausgabe erfolgt in geeigneter grafischer Form innerhalb des Programms und

kann idealerweise exportiert werden, um die Simulationsergebnisse der einzelnen

Schritte auswerten zu können.

Anforderungen 40

4 Anforderungen

In diesem Kapitel werden die Anforderungen an den zu entwickelnden Software-

Prototyp aufgelistet. Neben der Unterscheidung zwischen funktionalen sowie nicht-

funktionalen Anforderungen, wird hier auch festgelegt, welche dieser Anforderungen

Muss-Kriterien sind, gekennzeichnet mit [m], und welche Anforderungen in die Katego-

rie der Wunschkriterien fallen, welche mit [w] gekennzeichnet sind.

Im Rahmen dieser Arbeit soll ein Software-Prototyp entstehen. Dieser soll ein experi-

menteller Prototyp für Durchdringungsrechnungen von Zerspanverfahren sein, An ei-

nem Zerspanverfahren soll exemplarisch die Funktionalität demonstriert werden. Das

Zerspanverfahren der Wahl ist hierbei das bereits in Kapitel 2 eingeführte Schlagzahn-

fräsen als Analogieprozess zum Wälzfräsen. Der Prototyp soll eine Benutzungsober-

fläche zur Verfügung stellen, über die die Simulationsparameter eingestellt werden

können. Weiter soll darüber die wesentliche Steuerung realisiert werden. Der Prototyp

trägt im Folgenden den Arbeitstitel JCut, was keine vorgezogene Anspielung auf die zu

wählende Programmiersprache ist, sondern vielmehr für „Just cut“ steht. Dies macht

deutlich, dass es sich hierbei um ein Programm für Durchdringungsrechnungen han-

delt.

4.1 Anwendungsfälle

Die Abbildung 16 zeigt ein Anwendungsfalldiagramm der zu entwickelnden Anwen-

dung. Das Diagramm enthält einen Akteur, den Benutzer der Anwendung. Die darge-

stellten Anwendungsfälle werden im Folgenden kurz vorgestellt.

Programm starten

Der Programmstart ist der Anwendungsfall, der vor allen weiteren ausgeführt werden

muss. Alle weiteren Anwendungsfälle haben diesen als Vorbedingung. Aus Gründen

der Übersichtlichkeit wird in dem Diagramm auf die zahlreichen Include-Beziehungen

zu diesem Anwendungsfall verzichtet.

Simulationsparameter verändern/bestimmen

Der Benutzer erweitert hiermit den Anwendungsfall „Simulationsparameter festlegen“

und verändert dann somit die initialen Simulationsparameter.

Schneidprofil importieren

Ein Schneidprofil wird durch den Benutzer der Anwendung importiert. Dadurch wird der

Anwendungsfall „Simulationsparameter festlegen“ erweitert bzw. spezialisiert. Die Da-

ten der Schneide sind dabei über eine externe Datei in das Programm zu laden. Diese

Datei enthält die dafür notwendigen Daten.

Anforderungen 41

3D-Visualisierung des aktuellen Zustands

Dieser Anwendungsfall kann durch den Benutzer zu einem beliebigen Zeitpunkt nach

dem Programmstart ausgeführt werden. Die Vorbedingung ist hierbei der Anwendungs-

fall „Simulationsparameter festlegen“. Dies bedeutet, dass die 3D-Visualisierung immer

den Zustand der aktuellen Simulationsparameter repräsentiert.

Simulation starten

Die Simulation kann durch den Benutzer der Anwendung immer dann gestartet wer-

den, wenn die Vorbedingung „Simulationsparameter festlegen“ erfüllt ist. Dies ist be-

reits nach dem Systemstart der Fall, kann aber durch den Benutzer über zwei weitere

Anwendungsfälle angepasst werden.

Simulation vorzeitig stoppen

Der Benutzer der Anwendung kann bei Bedarf die Simulation jederzeit abbrechen. Die

Vorbedingung für diesen Anwendungsfall ist „Simulation starten“.

Simulationsparameter festlegen

Der Anwendungsfall „Simulationsparameter festlegen“ kann durch den Benutzer der

Anwendung nur indirekt über die zwei Anwendungsfälle „Simulationsparameter verän-

dern/bestimmen“ und „Schneidprofil importieren“ beeinflusst werden. Dieser Anwen-

dungsfall wird nach dem Systemstart mit Initialwerten versehen.

Simulationsergebnisse auswerten

Für diesen Anwendungsfall muss der Benutzer die Simulationsergebnisse in dem von

ihm definierten Ordner im Dateisystem entgegennehmen. Dieser Anwendungsfall hat

„Ergebnisse exportieren“ als Vorbedingung.

Simulationsergebnisse berechnen

Dieser Anwendungsfall hat als Vorbedingung „Simulation starten“ und erzeugt die Er-

gebnisse der Durchdringungsrechnung. Der Benutzer der Anwendung führt ihn dabei

nicht direkt aus, sondern lediglich implizit über den Anwendungsfall „Simulation star-

ten“.

Ergebnisse exportieren

Dieser Anwendungsfall wird ebenfalls nicht direkt durch den Benutzer der Anwendung

ausgeführt. Mit der Vorbedingung „Simulationsergebnisse berechnen“ werden die Er-

gebnisse, je nachdem wie die Simulationsparameter gewählt wurden, an einen Ordner

in einem verfügbaren Dateisystem geliefert.

Anforderungen 42

Abbildung 16: JCut Anwendungsfalldiagramm

4.2 Funktionale Anforderungen

JCut soll sowohl die Lückenkontur des Zahnrads sowie die anfallenden resultierenden

Spanungsquerschnitte ermitteln. Die Software kann über eine Visualisierungsfunktion

in 2D und 3D verfügen und ermöglicht die Ausgabe der Ergebniskoordinaten und Spa-

nungsquerschnitte in einem geeigneten Format. Dies ermöglicht eine weitergehende

Analyse der Daten in anderen Anwendungen. Die Software verfügt über eine Benut-

zungsoberfläche, über die Parameter für den Simulationsprozess einstellbar sind. Wei-

ter können Darstellungsoptionen sowie die Ausgabe der Daten hierüber gesteuert wer-

den.

Die folgenden Unterkapitel führen die einzelnen funktionalen Anforderungen getrennt

nach dem Anwendungsbereich auf.

4.2.1 Allgemeines

JCut muss Algorithmen und Modelle kapseln, damit diese zu einem späteren Zeitpunkt

ergänzt oder ersetzt werden können. JCut kann Multithreading unterstützen.

Anforderungen 43

4.2.2 Dateneingabe der Simulationsparameter

JCut muss eine Benutzungsoberfläche für die Interaktion mit dem Benutzer haben.

Notwendige Simulationsparameter müssen einstellbar sein. Zusätzliche, nicht erforder-

liche Simulationsparameter können einstellbar sein.

/F010/ Funktion zum Einlesen der Simulationsparameter, welche der Benutzer

über die Benutzungsoberfläche festlegt. [m]

/F020/ Eine Funktion, die die Benutzungsoberfläche mit Standardwerten initialisiert.

[w]

4.2.3 Einlesen von Geometriedaten

JCut kann Geometriedaten für Werkzeug und/oder Werkstück einlesen.

/F030/ Funktion zum Importieren von Geometrieinformationen für Werkzeug und

Werkstück. [w]

4.2.4 Berechnung von Simulationskenngrößen

JCut kann zusätzliche Berechnungen durchführen und ausgeben, z.B. Flächen von

Spanungsquerschnitten oder Richtungsvektoren der Schneide. Darüber hinaus kann

es nützliche Simulationskenngrößen errechnen und über die Benutzungsoberfläche

visualisieren.

/F040/ Eine Funktion, die die Anzahl der zu simulierenden Zeitkarten berechnet.

[m]

/F050/ Eine Funktion zur Berechnung der Gesamtlaufzeit4. [w]

/F060/ Eine Funktion zur Berechnung des Winkelfensters zwischen zwei aufeinan-

derfolgenden Simulationsschritten, bezogen auf Werkzeugbewegung. [w]

4.2.5 Durchführung der Durchdringungsrechnung

JCut muss beispielhaft ein Zerspanverfahren abbilden. Es muss eine Durchdringungs-

rechnung durchgeführt werden und kein analytischer Ansatz. Es müssen sowohl das

resultierende Werkstück als auch die dabei entstehenden Spanungsquerschnitte be-

rechnet werden. JCut kann Mehrschnittstrategien unterstützen. Hier wird nach einem

Simulationsdurchlauf ein weiterer durchgeführt, z.B. für das Schruppen und Schlichten.

/F070/ Eine Funktion für die Berechnung des Durchdringungszustands für jede

Zeitkarte. [m]

/F080/ Eine Funktion, die das Werkzeug mit dem Werkstück auf Überschneidun-

gen überprüft. [m]

4 Gemeint ist hier die Gesamtlaufzeit auf der simulierten Zeitachse und nicht die Rechenzeit.

Anforderungen 44

/F090/ Eine Funktion, die im Falle einer Überschneidung von Werkzeug und Werk-

stück das neue Werkstück berechnet. [m]

/F100/ Eine Funktion, die im Falle einer Überschneidung von Werkzeug und Werk-

stück die anfallenden Spanungsquerschnitte berechnet. [m]

/F110/ Es können mehrere Simulationsdurchgänge hintereinander ausgeführt wer-

den, ohne dass das Werkstück neu initialisiert wird (Mehrschnittstrategie).

[w]

/F120/ Eine Funktion, die es ermöglicht, eine Durchdringungsrechnung mit einer

Gangzahl > 1 durchzuführen. [w]

/F130/ Eine Funktion, die das Gleichlauf- sowie Gegenlaufverfahren beim Wälzfrä-

sen unterstützt. [m]

/F140/ Eine Funktion, die gleichsinniges sowie gegensinniges Wälzfräsen unter-

stützt. [m]

4.2.6 Visualisierung

JCut kann eine 2D- und/oder 3D-Visualisierung haben.

/F150/ Eine Funktion für die grafische Ausgabe von Simulationsschritten als 2D-

Grafik. [w]

/F160/ Eine Funktion für die grafische Ausgabe von Simulationsschritten als 3D-

Grafik. [w]

4.2.7 Export der Simulationsergebnisse

JCut muss die Simulationsergebnisse exportieren können, damit diese weiterverarbei-

tet werden können.

/F170/ Eine Funktion für die Ausgabe der Simulationsergebnisse zu einem Simula-

tionsschritt. [m]

4.2.8 Unterstützung von Mehrmonitorsystemen

Es können mehrere Monitore unterstützt werden.

/F180/ Ein Programmaufbau der Anwendung, welche den Betrieb auf Mehrmoni-

torsystemen sinnvoll ausnutzen kann. [w]

4.2.9 Abgrenzungskriterien

JCut versteht sich nicht als ein marktreifes Softwareprodukt, sondern als ein

experimenteller Prototyp.

Der Prototyp berücksichtigt keine Materialeigenschaften, sondern führt rein

geometrische Betrachtungen durch.

Anforderungen 45

Der Prototyp berücksichtigt keine Lasten (z.B. Kräfte, Wärmeströme), die aus

der Spanbildung resultieren.

4.3 Nicht funktionale Anforderungen

4.3.1 Performanz

Generell erwartet man von Software, dass sie die gegebenen Hardwareressourcen

sinnvoll nutzt. Für den Software-Prototyp JCut gilt dies besonders für Kinematik und

Schnittberechnungen, welche den wesentlichen Teil der Prozessorzeit ausmachen. Die

Arbeitsspeichernutzung ist hier ebenfalls ein wichtiger Punkt. Da bei jedem Simulati-

onsschritt neue Zustände für Werkzeug und Werkstück berechnet werden, sind diese

in geeigneter Weise zu speichern.

4.3.2 Qualitätsanforderungen / Genauigkeit

Die numerische Simulation eines Fertigungsprozesses bedingt zwangsläufig die Dis-

kretisierung von geometrischen Objekten und der Zeit für die einzelnen Simulations-

schritte. Die dafür entscheidenden Größen sollten variabel sein, müssen aber mindes-

tens transparent gemacht werden. Die numerische Genauigkeit der Ergebnisse soll

mindestens 6 signifikante Stellen nach dem Komma betragen.

4.3.3 Benutzbarkeit

Um die Benutzbarkeit sicherzustellen, ist die Oberfläche so zu gestalten, dass ein mit

der Problematik vertrauter Benutzer die Software intuitiv bedienen kann, ohne vorher

neue Begriffe zu erlernen. Aus diesem Grund ist darauf zu achten, dass entsprechende

etablierte Begriffe oder Standardbezeichnungen aus der Zerspanungslehre übernom-

men werden.

4.3.4 Einbettungsanforderung / Erweiterbarkeit

Da es sich um einen experimentellen Software-Prototyp handelt, muss der Quellcode

zugänglich und in seiner Struktur sinnvoll modularisiert sein, damit Teile ergänzt oder

ausgetauscht werden können.

4.3.5 Dokumentation

Der Quellcode ist zu dokumentieren, so dass Erweiterungen und Anpassungen nach-

träglich implementiert werden können. Darüber hinaus sind Variablen, Klassen und

Methode so zu benennen, dass sich der Inhalt bzw. deren Funktion möglichst intuitiv

erschließt. Die Benutzungsoberfläche ist mithilfe der möglichen Mittel mit einer einge-

bauten Unterstützungsfunktion auszustatten, z.B. „Tooltips“.

Anforderungen 46

4.3.6 Einführungsanforderungen

Der Umgang mit dem Software-Prototyp sollte den Benutzern demonstriert werden.

Dies kann neben einer Vorführung auch durch eine virtuelle Darstellung in Form eines

Anwendungsfallvideos geschehen. Entwicklern sollten neben der Dokumentation die

Algorithmen detailliert erläutert werden.

4.4 Umgebung

4.4.1 Technische Umgebung

Für den Betrieb von JCut sollen handelsübliche Rechner mit durchschnittlicher Ausstat-

tung genügen. Dabei soll es möglich sein, JCut sowohl auf 32-Bit- als auch auf 64-Bit-

Plattformen sinnvoll einsetzen zu können. Nach Möglichkeit ist eine plattformunabhän-

gige Lösung anzustreben, aber nicht zwingend erforderlich.

Folgende Voraussetzungen müssen minimal gegeben sein:

Prozessor: 32- oder 64-Bit-CPU mit einer Taktfrequenz von 2,0 Ghz oder höher

Arbeitsspeicher: Mindestens 256 MB freier Speicher für das Programm

Festplatte: Mindestens 500 MB freier Speicherplatz für das Programm sowie

das Speichern von Ergebnissen

Grafikkarte: Eine 3D-fähige Grafikkarte mit Direct3D- oder Open-GL-

Unterstützung

Betriebssystem: 32-Bit- oder 64-Bit-Version von Windows XP, Vista oder Windows 7

(Mac OS-X, Linux u.a. möglich, aber nicht getestet)

Empfohlene Voraussetzungen:

Prozessor: 64-Bit-Doppelkern-CPU mit einer Taktfrequenz von 2,0 Ghz oder

besser

Arbeitsspeicher: 2 GB RAM freier Speicher für das Programm

Festplatte: 5 GB freier Speicherplatz für das Programm sowie das Speichern

von Ergebnissen


Unterstützung

Betriebssystem: 64-Bit-Version von Windows 7

Anforderungen 47

4.4.2 Entwicklungsumgebung

Für die Entwicklung wird folgende Umgebung verwendet

Prozessor: 64-Bit-Doppelkern-CPU mit einer Taktfrequenz von 2,67 Ghz

Arbeitsspeicher: 2 GB RAM freier Speicher für das Programm

Festplatte: 5 GB freier Speicherplatz für das Programm sowie das Speichern

von Ergebnissen


Unterstützung

Betriebssystem: 64-Bit-Version von Windows 7

Weitere Software:

Java 6 Update 20, 64-Bit-Edition (Programmierung)

Java 3D 1.5.2, 64-Bit-Edition (zusätzliche Klassen für 3D-Kinematik und 3D-

Visualisierung)

Tortoise SVN 1.6.12, 64-Bit-Edition (Versionsverwaltung)

Eclipse 3.6 Helios, 64-Bit-Edition (Entwicklungsumgebung)

JFormDesigner 4.0.8, Eclipse Plug-in (Modul zur Gestaltung der Benutzungs-

oberflächen)

Systementwurf 48

5 Systementwurf

Das Kapitel Systementwurf beschreibt die Entwurfsentscheidungen für die Implemen-

tierung, dabei werden die Anforderungen aus dem vorigen Kapitel berücksichtigt. Wei-

ter werden hier alle Datenstrukturen und Datenformate spezifiziert.

5.1 Software-Prototyp JCut

Der Software-Prototyp JCut wird in Java entwickelt, da es sich aus mehreren Gründen

für diese Aufgabe eignet. Für Java ist der Compiler sowie die Laufzeitumgebung so-

wohl im 32- als auch 64-Bit kostenlos verfügbar. Darüber hinaus stehen viele Entwick-

lungsumgebungen ebenfalls kostenlos zur Verfügung. Als Basis für diese wissen-

schaftliche Arbeit und insbesondere für die Verwendung in einem experimentellen Pro-

totyp für Durchdringungsrechnungen, eignet sich Java aber besonders durch seine

umfangreiche API (Application Programming Interface). Für geometrische Berechnun-

gen im 2D- und 3D-Bereich (durch die Erweiterung Java3D) enthält die API eine Viel-

zahl sehr nützlicher Klassen, die Datenstrukturen sowie Methoden für die Berechnun-

gen liefern. Für die Fließkommawerte wird der Datentyp double mit doppelter Genauig-

keit verwendet, was bis zu 16 Nachkommastellen bedeutet. Die Wahl ist hierbei auf die

64-Bit Version gefallen, da die zusätzlich benötigten Klassen (Java3D) ebenfalls in 64-

Bit verfügbar sind. Somit stehen dem Prototyp bei Bedarf auch mehr als 4GB Arbeits-

speicher zur Verfügung.

5.1.1 Aufbau

JCut ist als Mehrfenster-Anwendung konzipiert. Dies hat mehrere Vorteile. Auf der ei-

nen Seite hat man immer alle Informationen nebeneinander einsehbar und hat damit

gleichzeitig die Möglichkeit, die Fenster nach Belieben auf mehrere Monitore (sofern

verfügbar) zu verteilen. Auf der anderen Seite lässt sich die Anwendung so einfach in

logische Komponenten gliedern. Bei JCut sind dies insgesamt drei Fenster. Das Haupt-

fenster verfügt über die 3D-Visualisierung, ein weiteres über die 2D-Visualisierung und

das dritte Fenster über die Benutzungsoberfläche, mit der alle Funktionen im Pro-

gramm gesteuert werden.

5.1.2 Visualisierung

Für die Visualisierung innerhalb der Anwendung stehen zwei Fenster zur Verfügung,

über die die Grafikausgabe möglich ist. Im Mittelpunkt steht hier die 3D-Visualisierung,

welche mit der Maus frei drehbar und skalierbar ist. Dabei lässt sich das Anwendungs-

fenster auf eine beliebige Größe ziehen und dessen Inhalt beliebig drehen, verschie-

ben und zoomen. Somit kann der Benutzer jederzeit bestimmen, welchen Ausschnitt er

Systementwurf 49

aus dem „virtuellen Universum5“ betrachten möchte. Das ist sogar dann möglich, wenn

eine Simulation läuft und währenddessen der aktuelle Fortschritt der Durchdringungs-

rechnung visualisiert wird. Dies wird dadurch erreicht, dass die eigentliche Durchdrin-

gungsrechnung in einem eigenen Thread gestartet wird. Somit ist das Hauptprogramm

weiter benutzbar und reagiert entsprechend auf Benutzereingaben. Das ist unter ande-

rem auch aus pragmatischen Gründen sinnvoll, da man ansonsten die Simulation nicht

anhalten könnte, ohne das Programm dabei zu beenden. Darüber hinaus stellt JCut

eine 2D-Visualisierung zur Verfügung, in der mit den Java-2D Klassen gezeichnet wer-

den kann. Dies kann z.B. für die Darstellung einer Schnittebene sinnvoll sein.

5.2 Parameter, Datenformate und Datenstrukturen

5.2.1 Diskretisierung

Die vier in Kapitel 2.4.1 eingeführten Diskretisierungsvarianten sollen nun auf die An-

zahl der entstehenden Objekte untersucht werden. Dabei ist die Anzahl der einzelnen

geometrischen Objekte sowohl vor als auch nach einer Durchdringung gemeint. Dazu

wird eine einfache geometrische Form gewählt, bei der eine definierte Materialmenge

abgetragen wird. Da bei einer Durchdringungsrechnung der wesentliche Aufwand darin

besteht, geometrische Objekte auf Überschneidungen zu untersuchen, wird anhand

dieser Größe ein Modell ausgewählt. Dies soll aber keine abschließende Bewertung

der Modelle sein. Es kann zu einem späteren Zeitpunkt durchaus sinnvoll sein, weitere

oder andere Diskretisierungsvarianten in JCut abzubilden.

Gegenüberstellung an folgendem Beispiel:

Gegeben sei ein Würfel mit einer Kantenlänge von 50 mm. An einer Seite soll eine

einfache Lücke mit 10 mm Kantenlängen gefräst werden (siehe Abbildung 17). Die

Auflösung soll eine Genauigkeit von 1 mm aufweisen.

Abbildung 17: Geometrie eines Würfels 5 Das virtuelle Universum ist die Bezeichnung innerhalb von Java3D für die abgebildete bzw.

simulierte Umgebung.

Systementwurf 50

Tabelle 3: Gegenüberstellung der Diskretisierungsvarianten bei der Durchdringungs-

rechnung/Wälzfräsen, insbesondere Schlagzahnfräsen6.

3-Dexel-Modell Voxel-

Modell Octree-Modell Polygonlinien-

modell

Rechenaufwand pro

Zeitkarte mittel groß groß klein

Anzahl der Objekte

initial7

50*50*3 =

7500

50*50*50 =

125000

<= 50*50*50 =

125000

50*4 =

200

Anzahl der Objekte

final8

50*50*3 +

(10*10*3) =

7800

(50*50*50) -

(10*10*10) =

124000

(50*50*50) -

(10*10*10) =

124000

40*4 +

10*8 =

240

Vorteile hohe Genauig-

keit beim Ab-

trag

bildet kom-

plettes Volu-

men ab

Optimierung des

Voxel-Modells,

lokal feinere

Auflösung mög-

lich

geringer Rechen-

aufwand,

hohe Genauigkeit

im Arbeitsbereich

Nachteile Rechen-

aufwand, be-

sonders bei

Fragmentierung

Rechen-

aufwand Rechen-

aufwand,

Schnitt von

unterschiedli-

chen Objekten

beschränkt sich

auf die Geometrie

der Randzone

Dimensionen bei

einem einzelnen

Durchdringungsschritt

3 3 3 2

Der Vergleich in Tabelle 3 zeigt eindeutig, dass bei dem Polygonlinienmodell die

kleinste Anzahl an geometrischen Objekten auftritt. Hierbei ist aber zu beachten, dass

eine Verallgemeinerung dieser Aussage dennoch schwierig ist, da sie auch von der

gewählten Geometrie abhängt. Ebenso ist ein Vergleich mit dem Octree-Modell gene-

rell nicht trivial, da dieses Modell im schlechtesten Fall so viele Objekte wie das Voxel-

Modell erzeugt, aber durchaus auch durch lokal feinere Auflösungen, ähnlich dem

Polygonlinienmodell, eine deutlich geringere Anzahl an Objekten erzeugen kann. Dabei

ist aber ebenso zu beachten, dass es rechenaufwändiger ist, geometrisch unterschied-

liche Objekte auf Durchdringung zu überprüfen und diese dabei in geeigneter Weise

neu zu erzeugen. Für den experimentellen Software-Prototyp wird das Polygonlinien-

6 Die Gegenüberstellung legt den Fokus auf die Anzahl der Objekte, die bei der Durchdrin-

gungsrechnung zum Schnitt gebracht werden müssen. 7 Gemeint ist hier die Anzahl der Objekte vor dem Schnitt. 8 Gemeint ist hier die Anzahl der Objekte nach dem Schnitt.

Systementwurf 51

modell verwendet, ohne dabei jedoch den Anspruch zu erheben, die

Diskretisierungsfrage abschließend beantwortet zu haben. Vielmehr muss der Prototyp

im Einsatz zeigen, wie gut dieses Modell funktioniert und wie es bei vielen sequentiel-

len Schnittberechnungen skaliert.

Das Polygonlinienmodell wird in Java durch die Datenstruktur einer doppelt verketteten

Liste (Klasse LinkedList) abgebildet. Die einzelnen Knotenpunkte der Liste ergeben

immer paarweise eine Polygonkante, wobei die Knotenpunkte neben ihren geometri-

schen Koordinaten weitere Informationen (siehe Tabelle 4) benötigen. Für diesen

Zweck wird ein Objekttyp JcutNode eingeführt, welcher die folgenden Datenfelder be-

sitzt:

Tabelle 4: JcutNode Feldnamen

JcutNode Feldname Beschreibung

node_nr Eindeutige Knotennummer

node_nr_ref Referenz auf Knotennummer in anderer Liste

x_coor X-Koordinate des Knotens

y_coor Y-Koordinate des Knotens

z_coor Z-Koordinate des Knotens

point_type Knotentyp (Normal, Schnittpunkt,…)

intersection_type Schnittpunkttyp (Regulär, liegt auf Knoten des WZ,

liegt auf Knoten des WST, liegt auf Knoten von WZ

und WST)

insert_index_wp Index für das Einfügen eines SP in das WST

insert_index_tl Index für das Einfügen eines SP in das WZ

mark_delete Löschmarkierung

cor_wp_node Zugehöriger Knoten in WST

cor_tl_node Zugehöriger Knoten in WZ

angle_tool Der Rotationswinkel des Werkzeugs

angle_prev Der Rotationswinkel des Werkzeugs (vorige Zeit-

karte)

angle_next Der Rotationswinkel des Werkzeugs (aktuelle Zeit-

karte)

direction_vector_x Richtungsvektor X-Koordinate

direction_vector_y Richtungsvektor Y-Koordinate

direction_vector_z Richtungsvektor Z-Koordinate

Systementwurf 52

5.2.2 Simulationsparameter und Optionen

Im Folgenden werden alle wichtigen Parameter, errechnete Simulationskenngrößen die

den Benutzer transparent sein müssen sowie die nötigen Simulationsoptionen be-

schrieben.

Tabelle 5: Einstellbare Simulationsparameter in JCut

Parametername Beschreibung

Spindel (rpm) Drehungszahl der Spindel in Umdrehun-

gen pro Minute.

Achslänge Spindel (mm) Achslänge der Werkzeugspindel in Milli-

meter.

Radius Spindel (mm) Radius der Werkzeugspindel in Millime-

ter.

Neigungswinkel Spindel (DEG) Neigungswinkel der Werkzeugspindel in

Grad (DEG).

Tangential-Vorschubweg (mm) Vorschubweg, der bei einem Durchgang

in tangentialer Richtung der Werkzeug-

achse verfahren wird, in Millimeter.

Axial-Vorschubweg (mm) Vorschubweg, der bei einem Durchgang

in axialer Richtung der Werkzeugachse

verfahren wird in, Millimeter.

Radial-Vorschubweg (mm) Vorschubweg, der bei einem Durchgang

in radialer Richtung der Werkzeugachse

verfahren wird in, Millimeter.

V-Tangential (mm/min) Vorschubgeschwindigkeit in tangentialer

Richtung in Millimeter pro Minute.*

V-Axial (mm/min) Vorschubgeschwindigkeit in axialer Rich-

tung in Millimeter pro Minute.

V-Radial (mm/min) Vorschubgeschwindigkeit in radialer Rich-

tung in Millimeter pro Minute.

Initialposition X Spindel (mm) X-Abstand vom Mittelpunkt der Werk-

zeugspindel, bezogen auf dessen Defini-

tion im Ursprung9, in Millimeter.

9 Die Definition der Spindel beginnt dabei im Ursprung und wächst entsprechend Ihrer Länge in

Y-Richtung.

Systementwurf 53


Initialposition Y Spindel (mm) Y-Abstand vom Mittelpunkt der Werk-



Initialposition Z Spindel (mm) Z-Abstand vom Mittelpunkt der Werk-



Gangzahl Anzahl der Gänge des Werkzeugs.

Anzahl der Zahnlücken Anzahl der Zahnlücken, die gefräst wer-

den sollen.

Vorschubweg für Wdh. (mm) Der gesamte Vorschubweb für alle Wie-

derholungen in Millimeter.

Vorschubweg pro Wdh. (mm) Vorschubweg für eine Wiederholung in

Millimeter.

Vorschubrichtung für Wiederholungen Vorschubrichtung für die Wiederholungen

(axial, radial, tangential).

Werkstückdurchmesser (mm) Werkstückdurchmesser in Millimeter.

Anzahl der Schnittebenen Anzahl der Schnittebenen.

Anzahl der Knoten je Schnittebene Diskretisierungsgröße in X- und Y-

Richtung des Werkstücks.

Höhe der Schnittebenen (mm) Diskretisierungsgröße in Z-Richtung des

Werkstücks.

Initialposition X Werkstück (mm) X-Abstand des Werkstücks, bezogen auf

dessen Definition im Ursprung10, in Milli-

meter.

Initialposition Y Werkstück (mm) Y-Abstand des Werkstücks, bezogen auf


meter.

Initialposition Z Werkstück (mm) Z-Abstand des Werkstücks, bezogen auf


meter.

Zeitkarten-Schrittweite (s) Dikretisierungsgröße der Zeitachse in

Sekunden.

Pause zwischen Zeitkarten (ms) Künstliche Verzögerung zwischen zwei

Zeitkarten, sinnvoll für eine nachvollzieh-

10 Das Werkstück ist mit seinem Mittelpunkt im Ursprung definiert.

Systementwurf 54


bare Kinematikvisualisierung.

Synchronisations offset (DEG) Manueller Korrekturwert für die errechne-

te Synchronisation zwischen Werkzeug

und Werkstück pro Zeitkarte in Grad

(DEG); wird auf den Rotationswinkel pro

Zeitkarte des Werkstücks aufgeschlagen

bzw. abgezogen.

Manueller Vorschubweg (mm)

Für die Simulationssteuerung: Vorschub-

schaltflächen

Vorschubschrittweite für die manuelle

Translation des Werkzeuges in Millimeter;

ermöglicht, Abstände abzuschätzen oder

das Werkzeug für eine freie Sicht auf das

Werkstück nach Simulationsende aus

dem Arbeitsbereich zu verschieben.

* Der Simulationsparameter „V-Tangential (mm/min)“ ist in JCut beliebig wählbar. Für

eine konkrete Durchdringungsrechnung des Schlagzahnfräsens befindet sich auf dem

beiliegenden Datenträger eine Berechnungshilfe in Form eines Excel-Dokuments. Die

Formel für die Berechnung des tangentialen Vorschubs pro Werkstückumdrehung wur-

de bereits in Kapitel 2.2.2 vorgestellt.

Systementwurf 55

Die folgenden berechneten Simulationskenngrößen müssen für den Benutzer einseh-

bar sein.

Tabelle 6: Errechnete Simulationskenngrößen in JCut

Berechnete Simulationskenngröße Beschreibung

Anzahl Zeitkarten pro Wiederholung Anzahl der Zeitkarten für das Fräsen ei-

ner Zeile, also ein Wiederholungsdurch-

lauf.

Anzahl der Wiederholungen Die Anzahl der Wiederholungen berech-

net sich durch: Vorschubweg für Wieder-

holung (mm) / Vorschubweg pro Wieder-

holung (mm)

Anzahl Zeitkarten gesamt Gesamtanzahl aller zu rechnenden Zeit-

karten; berechnet sich durch: Anzahl

Zeitkarten pro Wiederholung · Anzahl der

Wiederholungen

Drehwinkel pro Zeitkarte WZ (DEG) Drehwinkel des Werkzeugs (WZ) zwi-

schen zwei Zeitkarten; dient der Abschät-

zung, ob die gewählten

Diskretisierungsgrößen sinnvoll gewählt

wurden.

Drehwinkel pro Zeitkarte WS (DEG) Drehwinkel des Werkstücks (WS) zwi-

schen zwei Zeitkarten.

Maschinenlaufzeit (min) Errechnete Maschinenlaufzeit, welche

anhand der Vorschub- und Rotationsge-

schwindigkeit ermittelt wurde; ist nicht mit

der Simulationszeit zu verwechseln, wel-

che von der vorhandenen Hardware und

der gewählten Diskretisierungsauflösung

abhängt.

Tabelle 7: Simulationsoptionen in JCut

Simulationsoptionen Beschreibung

3D-Texturen Option für die 3D-Visualisierung; ohne

Texturen sieht man das Java3D Drahtgit-

termodell.

Systementwurf 56

Simulationsoptionen Beschreibung

3D-Koordinatensystem Option für das Ein- bzw. Ausblenden des

Koordinatensystems.

3D-Visualisierung während der Simulation Option für das Ein- bzw. Ausschalten der

3D-Visualisierung der einzelnen Simulati-

onsschritte.

3D-Visualisierung nur nach erfolgtem

Schnitt

Option für die Beschränkung der 3D-

Visualisierung auf die Zeitkarten nach

einem ausgeführten Schnitt.

Anzahl der simulierten Zahnlücken Anzahl der zu simulierenden Zahnlücken;

alle anderen werden kinematisch berück-

sichtigt, aber der Schnitt nicht durchge-

führt.

CSV-Export der Ergebnisse Option für das Ein- bzw. Ausschalten des

CSV-Exports der Ergebnisse.

CSV-Export in detaillierter Ausführung Option für das Ein- bzw. Ausschalten des

detaillierten Exports; zusätzlich werden

Winkelpositionen sowie ein Richtungsvek-

tor des Werkzeugs ausgegeben.

CSV-Export nur für eine Zahnlücke Option für die Beschränkung des Exports

auf lediglich eine Zahnlücke; Ergebnisse

sollten bis auf rundungsbedingte Unge-

nauigkeiten bei allen Zahnlücken iden-

tisch sein.

CSV-Exportpfad Pfad im lokalen Dateisystem, in den JCut

die Ergebnisse exportieren soll.

Tabelle 8: Steuerungselemente in JCut

Steuerungselement Beschreibung

Simulationsparameter einlesen Dient dazu, die vom Benutzer angepass-

ten Simulationsparameter einzulesen und

die 3D-Visualisierung entsprechend zu

aktualisieren.

Werkzeug einlesen Dient zur Auswahl einer CSV-Datei, wel-

che die Koordinaten einer Werkzeug-

schneide enthält.

Systementwurf 57

Steuerungselement Beschreibung

Start Simulation Startet die Durchdringungssimulation mit

den gewählten Parametern und Optionen.

Stop Simulation Beendet die Simulation bei der aktuellen

Zeitkarte.

Pfeilschaltflächen für den manuellen Vor-

schub

Verschiebt die Werkzeugschneide in X-

bzw. Y-Richtung. Dient dazu, die Schnei-

de aus dem Sichtfeld zu verschieben,

wenn man das fertige Werkstück betrach-

ten möchte. Alternativ kann mit dieser

Funktion in Verbindung mit dem manuel-

len Vorschubweg (mm) leicht eine Entfer-

nung abgeschätzt werden. Die verscho-

bene Geometrie einer Schneide wird in

einer anschließenden Simulation nicht

übernommen.

3D-Ansicht zurücksetzen Das „virtuelle Universum“ in der 3D-

Ansicht lässt sich um alle drei Achsen frei

drehen sowie verschieben und skalieren.

Diese Schaltfläche stellt die ursprüngliche

Ansicht der 3D-Visualisierung wieder her.

5.2.3 Eingabeformat der Geometriedaten

Für die Eingabe von Geometriedaten, z.B. dem Einlesen eines konkreten Schneidpro-

fils, wird das CSV-Format verwendet. Die Daten werden gemäß der Diskretisierung als

Folge von 2D-Punkten eingelesen. Das Werkzeug wird dabei an der Mitte der Werk-

zeugspindel ausgerichtet, dessen Rotationsachse initial im Ursprung beginnt und paral-

lel zur Y-Achse verläuft. Die importierte Schneidgeometrie wird durch Koordinatenver-

schiebung auf der Oberfläche der berechneten Werkzeugspindel platziert, also noch-

mal um den Radius der Spindel in X-Richtung verschoben. Das unbearbeitete Werk-

stück wird aufgrund seiner simplen Zylinderform über das Benutzungsinterface in sei-

nen Dimensionen bestimmt. Hier wäre ebenfalls ein Import denkbar, welcher aber für

die Funktion nicht notwendig ist.

Systementwurf 58

Abbildung 18: CSV-Daten Schneidprofil

Die Reihenfolge gibt hier auch die Richtung des Polygonzugs vor. Dabei ist zu beach-

ten, dass das Programm Polygonzüge im Uhrzeigersinn erwartet. Das Trennzeichen

der Wertpaare ist hierbei das Semikolon. Hier wurde das Standardformat berücksich-

tigt, welches Microsoft Excel verwendet, wenn man Fließkommazahlen in einem CSV-

Dokument abspeichert. Die Fließkommazahlen können beliebig mit Komma oder Punkt

als Trennzeichen versehen werden. Java benötigt Fließkommazahlen immer mit einem

Punkt als Trennzeichen; dies ist bei dem Import entsprechend zu berücksichtigen und

evtl. vorkommende Kommata sind durch Punkte zu ersetzen.

5.2.4 Ausgabeformat der Simulationsdaten des Exportmoduls

Das Ausgabeformat für Ergebnisse der Durchdringungsrechnung nutzt ebenfalls das

CSV-Format. Hier werden Werkstückknoten, Werkzeugknoten sowie Knoten der Spa-

nungsquerschnitte nebeneinander ausgegeben. Für die Spanungsquerschnitte wird

darüber hinaus noch die berechnete Fläche angegeben. Zusätzlich ist es möglich, wei-

tere Detailinformationen, wie z.B. das Werkzeug mit Richtungsvektoren, in zusätzlichen

Spalten der CSV-Datei auszugeben. Aufgrund der Menge an Informationen befinden

sich Beispiele im Anhang B.

5.3 Externe Software sowie verwendete Bibliotheken

Für die Entwicklung von JCut werden die Java3D-Erweiterungsklassen in Version 1.5.2

sowie das externe Eclipse Plug-in JFormDesigner verwendet. Dieses Modul wird dazu

benutzt, die Benutzungsoberfläche über einen WYSIWYG-Editor zu gestalten.

Systementwurf 59

Java3D

Diese zusätzlichen Klassen wurden 1997 von Sun (dem ehemaligen Java-Entwickler

und Rechteinhaber) entwickelt. Nachdem Sun die Entwicklung zwischenzeitlich einge-

stellt hatte, wurde das Projekt 2004 als Open-Source freigegeben und seitdem im

Rahmen der Open-Source-Gemeinschaft weiterentwickelt. Diese Klassen stellen Struk-

turen und Methoden für Berechnungen und Visualisierungen im dreidimensionalen

Raum zur Verfügung. Java selbst liefert in seiner Grundausstattung lediglich Klassen

für zweidimensionale Berechnungen (vgl. [Java3D 2011]).

JFormDesigner

Die Firma FormDev stellt mit Ihrem Produkt JFormDesigner einen Java Swing Desig-

ner zur Verfügung, der neben einer Einzelanwendung auch als Eclipse Plug-in zur Ver-

fügung steht. Eclipse stellt als Entwicklungsumgebung keinen eigenen Swing Editor zur

Verfügung sondern lediglich für die eigene SWT-Grafikklasse. Um mit Eclipse Oberflä-

chen mit den Java 2D-Standardklassen (Swing) gestalten zu können, bedarf es entwe-

der Handarbeit ohne WYSIWYG-Editor oder aber einer Lösung wie dem

JFormDesigner (vgl. [JFormDesigner]).

5.4 Klassen

JCut ist in die folgenden Klassen aufgeteilt:

JCut

Diese Hauptklasse beinhaltet die Elemente der Durchdringungsrechnung sowie der

3D-Visualisierung, welche beide auf die Java3D-Klassen zurückgreifen.

JCutNode

Diese Klasse stellt die bereits in 5.2.1eingeführte Datenstruktur für Knotenelemente der

Polygonlinien zur Verfügung.

GenericShape2D

Diese Klasse erzeugt aus JCutNode-Polygonlinien 3D-Objekte, welche dann in der

Hauptklasse JCut visualisiert werden können. Um dies zu erreichen, wird ein

GenericShape2D-Objekt erzeugt, welches die Java3D-Klasse Shape3D erweitert. Um

ein solches Objekt zu erzeugen, muss eine Liste von JCutNodes sowie die gewünschte

Höhe des 3D-Objektes übergeben werden.

Draw2DPanel

Die Draw2Dpanel-Klasse erzeugt ein neues Fenster, welches für 2D-Visualisierungen

zur Verfügung steht. Hier können z.B. einzelne Schnittebenen visualisiert werden. Um

dies zu ermöglichen, werden die Listen von JcutNodes in Java2D-Swing-Strukturen

überführt. Dazu gehört z.B. die Struktur Path2D, welche dann mit einer Füllfarbe ver-

sehen werden kann, um schließlich gezeichnet zu werden. Path2D entspricht dabei

Systementwurf 60

einer Polygonlinie im zweidimensionalen Raum und ist auch für Koordinaten mit dop-

pelter Fließkommagenauigkeit verfügbar.

ControlPanel

Die Klasse ControlPanel erzeugt ein neues Fenster, welches die Benutzungsoberflä-

che enthält. Hier werden alle einstellbaren Parameter und Simulationsoptionen abge-

bildet. Darüber hinaus wird über dieses Fenster die Simulation gestartet sowie ge-

stoppt, falls man eine laufende Simulation beenden möchte. Die Benutzungsoberfläche

wurde dabei mit dem in 5.3 eingeführten JFormDesigner gestaltet, welcher auf Wunsch

leere Methoden für die Implementierung der Interaktion (Event Handler) zur Verfügung

stellt.

5.5 Kinematik von Wälzfräser und Werkstück

Die Komponenten der Kinematik werden innerhalb der Hauptklasse „JCut“ mithilfe der

Java3D-API berechnet. Für die Rotationen stellt die Java3D-API Methoden zur Verfü-

gung, mit der Punktkoordinaten um einen beliebigen Ursprungsvektor rotiert werden

können. Hierfür übergibt man der Struktur AxisAngle4d den Ursprungsvektor, um den

rotiert werden soll sowie den gewünschten Drehwinkel. Soll um einen Vektor rotiert

werden, der kein Ursprungsvektor ist, so muss man die Geometriedaten der zu rotie-

renden Punkte in Richtung Ursprung um genau den Betrag verschieben, der die Diffe-

renz des gewünschten Vektors zu einem passenden Ursprungsvektor ausmacht.

In Abbildung 19 ist dieser Zusammenhang dargestellt. Die beiden Ortsvektoren und

definieren die Rotationsachse, um die die Geometriedaten eines Objektes gedreht

werden sollen. Da der Verbindungsvektor nicht im Ursprung beginnt, muss für die

Rotation mit der Java3D-Struktur AxisAngle4d ein passender Ursprungsvektor gefun-

den werden. Dieser Ursprungsvektor ist genau dann passend, wenn er parallel zum

dem eigentlichen Vektor verläuft.

Die Bestimmung dieses Ursprungsvektors wird durch eine Translation, der Rotation-

sachse sowie dem Objekt, welches rotiert werden soll, erreicht. Die Translation

erfolgt um den negativen Betrag des Ortsvektors . Um den Ursprungsvektor ′ =

- = ′ kann nun das verschobene Objekt rotiert werden. Nach erfolgter Rotati-

on wird das Objekt wieder um den positiven Betrag von zurückverschoben. Dieses

Vorgehen entspricht einer direkten Rotation um den Verbindungsvektor .

Systementwurf 61

Abbildung 19: Zusammenhang Rotationsachse - Ursprungsvektor

Translationen werden durch Veränderung der XYZ-Komponenten erreicht. Ein ent-

scheidendes Merkmal der Kinematik in JCut ist, dass die Berechnung von geometri-

schen Positionen im Raum nicht aufbauend geschieht, sondern für jede Zeitkarte der

Simulation anhand der initialen Position neu berechnet wird. Ein wesentlicher Vorteil ist

dabei, dass sich Rundungsfehler so nicht aufaddieren können. JCut hält hierfür z.B.

eine Kopie des Werkzeugs bereit, welche während der Simulation nicht verändert wird

und somit die Startposition des Werkzeugs repräsentiert. Diese Kopie wird für jede

Zeitkarte verwendet, um die aktuelle Position des Werkzeugs zu dem gegebenen Zeit-

punkt zu errechnen. Dabei wird zuerst die Rotation des Werkzeugs berechnet und an-

schließend auf das Ergebnis die Translation angewendet.

Im Gegensatz zu dem Ansatz, der in [Sulzer 1973] verfolgt wird (vgl. auch Kapitel

2.4.2), beschreibt JCut die Werkzeugschneide nicht in dem werkradfesten Koordina-

tensystem der Zahnlücke, sondern die gesamte Geometrie des Prozesses in einem

gemeinsamen Koordinatensystem. Dabei handelt es sich um ein dreidimensionales,

kartesisches Koordinatensystem. Die Durchdringungsrechnung muss dabei im ersten

Oktanten stattfinden, da einige Algorithmen nur korrekt funktionieren, wenn alle Punkte

in diesem Bereich liegen, also alle XYZ-Koordinaten positiv sind.

5.6 Durchdringungsrechnung

Um die Durchdringungsrechnung durchführen zu können, wird die Werkzeugschneide

in den Schnittebenen des Werkstücks beschrieben. Dazu wird die Bahn der Werk-

zeugschneide pro Werkzeugumdrehung in einem festgelegten Winkelfenster aufge-

zeichnet. Die aufgezeichnete Bahn wird nun mit den einzelnen Schnittebenen auf

Systementwurf 62

Schnittpunkte untersucht, um bestimmen zu können, wo die einzelnen Knoten der

Werkzeugschneide die Schnittebenen durchdringen. Diese Knoten in der jeweiligen

Schnittebene bilden die „virtuelle Schneidkontur“ (vgl. [Sulzer 1973], S. 35). Das Poly-

gon der virtuellen Schneidkontur sowie des Polygons der Schnittebene wird dann mit

einem Polygonschnittalgorithmus untersucht und ggf. die Schnittmenge sowie die Diffe-

renz bestimmt.

5.6.1 Zeitdiskretisierung

Die Zeitachse für die einzelnen Simulationsschritte wird in JCut anhand der in 5.2.2

vorgestellten Parameter aufgebaut. Der Benutzer gibt die Schrittweite selber vor und ist

damit verantwortlich für eine sinnvolle zeitliche Auflösung. Wählt man hier eine zu gro-

be Auflösung, so kann man durch einfache Überlegungen feststellen, dass diese ge-

wählte Größe zu keinem sinnvollen Ergebnis führen kann. Selbst bei einer langsamen

Drehgeschwindigkeit von 1000 U/min würden pro Sekunde ca. 17 Umdrehungen statt-

finden. Man würde also nur jede 18. Umdrehung simulieren und alles dazwischen nicht

berücksichtigen. Es ist daher darauf zu achten, dass eine Schrittweite gewählt wird, die

ein sinnvolles Winkeldrehfenster als Ergebnis hat.

JCut unterstützt seinen Anwender dadurch, dass diese berechneten Größen über die

Benutzungsoberfläche einsehbar sind und somit leicht eine Einschätzung getroffen

werden kann. Wie lange, d.h. wie viele Zeitkarten eine Simulation insgesamt benötigt,

errechnet JCut ebenfalls anhand von den variablen Simulationsparametern. JCut mit-

telt hier, wie lange es in Sekunden dauert, bis ein eingestellter Vorschubweg mit einer

eingestellten Vorschubgeschwindigkeit durchlaufen ist. Zusammen mit der Zeitkarten-

schrittweite ergibt sich dann die Gesamtanzahl der zu rechnenden Zeitkarten. Wie lan-

ge JCut für die Ergebnisberechnung von einer Zeitkarte benötigt, hängt von den

Diskretisierungsparametern sowie der Geschwindigkeit des Rechners, auf dem JCut

läuft, ab.

5.6.2 Polygonschnitt nach Weiler-Atherton

Für die Durchdringungsrechnung wird der bereits in Kapitel 2.4.3 vorgestellte Weiler-

Atherton-Algorithmus verwendet, der sich aufgrund seiner einfachen logischen Struktur

für die Verwendung zum Schnitt von überschneidungsfreien Polygonen eignet. Der

Algorithmus erzeugt als Ergebnis der Schnittmenge oder der Differenz von zwei Poly-

gonen direkt die Polygone, die man erwartet und muss keine zusätzlichen

Optimierungen, wie z.B. die Beseitigung von zusätzlichen Kanten (Sutherland-

Hodgman-Algorithmus), auf den Ergebnissen durchführen. Allerdings sollte man die

Performanz im Einsatz des Prototyps beachten. Sollte sich herausstellen, dass die

Rechenzeit für den Polygonschnitt einen so großen Zeitabschnitt in Anspruch nimmt,

dass eine Reduzierung der Rechenzeit nötig erscheint, kann es Sinn machen, diesen

Algorithmus gegen einen anderen zu ersetzen oder gar für den Benutzer selektierbar

zu machen. JCut unterstreicht hiermit seine experimentelle Funktion.

Systementwurf 63

Für die Berechnung von Polygonschnittmengen und der Differenz von zwei Polygonen

wird entsprechend des Algorithmus verfahren, um das neue Werkstück (Differenz) so-

wie die Spanungsquerschnitte (Schnittmenge) zu berechnen. Die Datenstruktur der

JCutNodes stellt hier geeignete Datenfelder zur Verfügung, um zwischen den Struktu-

ren beliebig wechseln zu können, nachdem die gefundenen Schnittpunkte in das

Werkstück und Werkzeug eingefügt wurden. Die Schnittpunkte werden in das Werk-

zeug bzw. in eine Kopie des Werkzeugs eingefügt, um die Schnittberechnungen

(Wechseln zwischen den beiden Polygonzügen) zu ermöglichen. Die Anzahl der Kno-

ten des Werkzeugs verändert sich aber zwischen zwei Zeitkarten nicht. Das Original-

Werkzeug11 wird während der gesamten Durchdringungsrechnung nur durch den

Raum bewegt.

11 Alle Berechnungen erfolgen mit einer Kopie des Werkzeugs.

Implementierung 64

6 Implementierung

In diesem Kapitel sollen einige ausgewählte Kernkomponenten des Software-Prototyps

JCut vorgestellt werden. Bei der Entwicklung dieser Software-Komponenten traten an

einigen Stellen besondere Schwierigkeiten auf, welche im Folgenden mit dem dazuge-

hörigen Lösungsansatz beschrieben werden.

6.1 Zeitlicher Ablauf und Komponenten

Die drei Komponenten Schnittalgorithmus, Abbildung der Kinematik sowie 3D-

Visualisierung haben den größten Teil der Implementierungszeit beansprucht. Dabei

hat sich die Verteilung innerhalb dieser drei Komponenten deutlich anders verteilt, als

dieses zu erwarten war. Der gewählte Schnittalgorithmus für Polygone hat hier deutlich

mehr Zeit beansprucht, als dies bei der Wahl des Weiler-Atherton-Algorithmus zu er-

warten war. Dabei haben sich insbesondere die Sonderfälle, welche in 6.2.2 vorgestellt

werden, als besonders zweitaufwendig herausgestellt. Die Abbildung der Kinematik

des Schlagzahnfräsens war dagegen deutlich weniger zeitaufwändig als zunächst an-

genommen. Diese unerwartete Zeitersparnis ist auf die Verwendung der Java3D-API

zurückzuführen, welche sich durch die Möglichkeiten der 3D-Visualisierung und der

Methoden für Kinematikberechnungen auszeichnete. Während der Umsetzung war es

immer wieder notwendig zu überprüfen, ob das gewünschte kinematische Verhalten

auch korrekt implementiert wurde. Dabei wurden die Tests auf korrektes Verhalten

intensiv durch die 3D-Visualisierung unterstützt. Ursprünglich war die 3D-Visualisierung

als Wunschkriterium geplant, für den Fall, dass dafür noch genügend Zeit bleibt. Die

Entscheidung diese aber in jedem Fall umzusetzen, fiel bei den schon angesproche-

nen Tests. Hier konnte bei Fehlern in der Umsetzung bzw. fehlerhafter Verwendung

der Java3D-Methoden in den meisten Fällen schon durch eine einfache Sichtkontrolle

festgestellt werden, dass etwas nicht richtig funktioniert. Die aufwendige Kontrolle der

resultierenden Koordinaten von Werkzeug und Werkstück konnte somit sinnvoll redu-

ziert werden.

6.2 Weiler-Atherton-Algorithmus

6.2.1 Schnittpunkte

Die Schnittpunktberechnung von zwei Polygonen gestaltet sich auf den ersten Blick

relativ einfach. Zu jedem Polygonsegment der zwei Polygonzüge existiert eine Gerad-

engleichung. Jedes Polygonsegment von dem schneidenden Polygon kann nun an-

hand dieser Geradengleichungen mit jedem Polygonsegment des zu schneidenden

Polygons auf Schnittpunkte überprüft werden. Verlaufen zwei Geraden nicht parallel,

so schneiden sie sich im zweidimensionalen Raum. Der so bestimmte Schnittpunkt

Implementierung 65

muss nun noch weiter untersucht werden. Es muss bestimmt werden, ob dieser auf

den beiden Polygonsegmenten liegt, welche einen Abschnitt der Geraden repräsentie-

ren. Die Java2D-API stellt für derartige Untersuchungen einen Typ für Liniensegmente

zur Verfügung (Line2D.Double) sowie eine Methode zur Überprüfung ob diese beiden

Liniensegmente sich schneiden (boolean intersectsLine(Line2D l)). Eine Methode zur

Bestimmung dieses Schnittpunktes fehlt der API jedoch. Aus diesem Grund wird in der

JCut-Implementierung mit der oben genannten Methode zuerst überprüft, ob die Seg-

mente sich überhaupt schneiden und anschließend der Schnittpunkt berechnet. Für die

Berechnung des Schnittpunktes wird eine eigene Implementierung verwendet, die an-

hand der Geradengleichungen der zwei Segmente den Schnittpunkt bestimmt.

6.2.2 Sonderfälle

Sind alle Schnittpunkte bestimmt, werden diese in die Polygonzüge eingefügt. Hierfür

wird vorerst auf einer temporären Kopie gearbeitet, da die Schnittpunkte eine Sonder-

fallbehandlung durchlaufen müssen.

Abbildung 20: Weiler-Atherton-Sonderfälle

Bei dem Schnitt von Polygonen gibt es verschiedene Fälle, die eintreten können, die

die Funktionalität des Weiler-Atherton-Algorithmus verhindern, sofern diese nicht be-

Implementierung 66

handelt werden. Darüber hinaus gibt es Fälle, die zwar hinnehmbar wären, aber zu

unnötig vielen Knoten führen würden. In Abbildung 20 sind die wesentlichen Merkmale

dieser Sonderfälle dargestellt. In Teil 1 der Abbildung liegen gleich mehrere Probleme

vor. Zum einen bilden zwei Kanten von Polygon B einen identischen Schnittpunkt mit

Polygon A, zum anderen liegen diese Schnittpunkte auch direkt auf einem Knoten von

Polygon B. Ein weiteres Problem ist dabei, dass gar keine Schnittberechnung notwen-

dig wäre, da Polygon B nicht in Polygon A eintritt, sondern nur anliegt.

Teil 2 der Abbildung verstärkt das Problem weiter, indem die Anzahl der Schnittpunkte

auf vier angewachsen ist. Hier sind es jeweils zwei Kanten von Polygon A und B, die

identische Schnittpunkte erzeugen, welche sowohl auf einen Knoten von Polygon A als

auch von Polygon B fallen. Es gibt aber auch Fälle, in denen eine identische Situation

wie in Teilbild 2 vorliegt, sich die Polygone aber schneiden und eine Schnittberechnung

durchgeführt werden muss. So ein Beispiel ist in Teilbild 3 zu sehen.

Ein weiteres Problem ist in Teilbild 4 dargestellt, hier liegen zwei Kanten aufeinander,

was zu unendlich vielen Schnittpunkten führen würde. Darüber hinaus bilden aber zwei

weitere Kanten von Polygon B jeweils einen Schnittpunkt mit Polygon A und dennoch

findet kein Schnitt statt, da auch hier das Polygon B nur anliegt.

Die Implementierung von JCut behandelt diese Sonderfälle und weitere Sonderfälle

durch die folgenden Überprüfungen.

I. Schnittpunkte mit identischen Koordinaten werden bis auf einen Schnittpunkt

verworfen.

II. Parallele Polygonsegmente werden nicht auf Schnittpunkte untersucht.

III. Schnittpunkte, die auf Knoten von Polygon A und/oder B fallen, werden als sol-

che markiert.

IV. Jeder Schnittpunkt wird darauf untersucht, ob durch diesen das eine Polygon in

das andere eintritt oder nur anliegt. (vgl. Abbildung 20 Teil 2 und 3)

Die erste Überprüfung (I.) stellt sicher, dass nicht mehrere Schnittpunkte an identischer

Position entstehen. Somit wird immer nur ein Schnittpunkt in die Polygonzüge einge-

fügt.

Die zweite Überprüfung (II.) vermeidet unendliche viele Schnittpunkte bei parallelen

Polygonsegmenten. Zwei Polygonkanten die aufeinanderliegen, führen nie zu einem

Schnitt von zwei Polygonen. Entscheidend ist hier, wie die jeweils vorige bzw. nächste

Kante verläuft. Aus diesem Grund ist das Auslassen unproblematisch.

Die dritte Überprüfung (III.) sorgt dafür, dass Schnittpunkte, die auf einen Polygonkno-

ten fallen, nicht zusätzlich eingefügt werden. Hier wird der schon bestehende Punkt auf

dem Polygon als Schnittpunkt markiert.

Besonders anspruchsvoll ist die algorithmische Umsetzung für die letzte der vier Über-

prüfungen (IV.). Ein Ansatz der hier nicht zum Ziel führt, ist die Untersuchung der Kno-

ten vor und nach dem jeweiligen Schnittpunkt auf dem entsprechenden Polygon. Hier-

für ein geeignetes Verfahren zu entwickeln, hat bei der Umsetzung die meiste Zeit in

Implementierung 67

Anspruch genommen. Die Lösung ist nicht allein in den anderen Knoten zu finden,

sondern in den Polygonkanten die diese bilden. Da bei dem Weiler-Atherton-

Algorithmus eine Richtung vorgegeben ist und jeder Schnittpunkt als Eintritts- bzw.

Austrittsschnittpunkt markiert ist, entscheidet bei einem Eintrittsschnittpunkt die nächs-

te Kante und bei einem Austrittsschnittpunkt die vorige Kante des schneidenden Poly-

gons, ob ein echter Schnittpunkt vorliegt.

Abbildung 21: Weiler-Atherton-Sonderfallbehandlung

Abbildung 21 zeigt diesen Zusammenhang anhand von vier Beispielen. In Teilbild 1

gibt es sowohl einen Eintritts- wie auch einen Austrittsschnittpunkt. Einer dieser beiden

Punkte wird durch die oben erwähnte Überprüfung (I.) verworfen. Welcher dieser bei-

den Knoten das ist, spielt keine Rolle. Ein Eintrittspunkt, der auf einem Austrittspunkt

liegt, ist gleichbedeutend mit zwei anliegenden Polygonsegmenten. Der verbleibende

Schnittpunkt wird durch die Überprüfung (IV.) als Schnittpunkt einer anliegenden Kante

erkannt. Die Überprüfung (IV.) ist an einem weiteren Beispiel in Teilbild 3 und 4 darge-

stellt. Hier wird die vorige Kante auf dem Werkzeugpolygon überprüft. Dazu wird auf

Implementierung 68

dieser Kante am Ende12 ein Kontrollpunkt bestimmt. Dieser Kontrollpunkt hat den Ab-

stand der vorgegebenen Simulationsschnittgenauigkeit13. Danach wird durch eine

Hilfsmethode überprüft, ob dieser Kontrollpunkt innerhalb des Werkstückpolygons liegt

oder sich außerhalb befindet. Liegt der Schnittpunkt innerhalb des Werkstückpolygons,

bleibt der Schnittpunkt bestehen und wird ansonsten verworfen.

6.3 Kinematikberechnungen

6.3.1 Synchronisation zwischen Werkzeug und Werkstück

Die aktuellen Positionen des Werkzeugs sowie des Werkstücks müssen zu jedem

Zeitpunkt berechnet werden. Dabei hängt die Position des Werkstücks von der Position

des Werkzeugs ab. Die Bewegungen der beiden geometrischen Objekte sind synchro-

nisiert. Dabei ist besonders darauf zu achten, dass diese Synchronisation erhalten

bleibt, wenn ein Rückhub des Werkzeugs stattfindet, um nach einem diskontinuierli-

chen Axialvorschub die nächste Zeile zu simulieren. JCut verfolgt hierbei den folgen-

den Ansatz, um diese Vorgabe zu erfüllen:

Die Initialposition des Werkzeugs sowie dessen Drehachse werden für die Be-

rechnung von jeder Einzelposition des Werkzeugs zu jeder Zeitkarte verwendet.

Die Position des Werkstücks wird dagegen anhand der Ortsinformationen der

vorigen Zeitkarte bestimmt.

Das Werkstück wird nach einem abgeschlossenen Durchlauf einer Zeile um

den Gesamtbetrag der bisher durchgeführten Drehung zurückrotiert.

Die Startposition des Werkzeugs sowie dessen Drehachse werden nach einem

abgeschlossenen Durchlauf einer Zeile in axialer Richtung verschoben.

Im Gegensatz zu dem Werkzeug und der Drehachse des Werkzeugs kann die Position

des Werkstücks zu einer Zeitkarte nicht aufgrund dessen Initialposition bestimmt wer-

den. Dies ist aufgrund der ständigen Veränderung14 des Werkstücks nicht möglich. Das

Werkzeug hingegen verändert sich während der gesamten Durchdringungsrechnung

nicht und wird lediglich im Raum bewegt.

Für die konkrete Umsetzung dieser synchronisierten Rotationen, wird zuerst die Menge

der benötigten Zeitkarten pro simulierte Zeile bestimmt. Anhand der Vorschubge-

schwindigkeit und des Vorschubweges wird die dafür benötigte Zeit in Sekunden er-

rechnet. Dieser Wert wird anschließend durch die Zeitkartenschrittweite dividiert und

somit die Anzahl der zu simulierenden Zeitkarten bestimmt. Anhand der Rotationsge-

schwindigkeit des Werkzeugs wird der Rotationswinkel pro Zeitkarte bestimmt. Dieser

Winkel wird dem Benutzer transparent gemacht, damit eine Prüfung der Sinnhaftigkeit

12 Bei Eintrittsschnittpunkten analog am Anfang der nächsten Kante (vgl. Abbildung 21 / 2). 13 Eine feste, vom Benutzer nicht beinflussbare Kenngröße, die den Abstand zweier Knoten

beschreibt, welcher nötig ist, damit zwei Knoten nicht als gleich gelten. 14 Abtrag durch Durchdringungsrechnung

Implementierung 69

erfolgen kann. Das Winkelfenster des Werkstücks berechnet sich nun direkt aus dem

Winkelfenster des Werkzeugs, dessen tangentialem Vorschub sowie der Zähnezahl.

In

Tabelle 9 sind die JCut-Variablen beschrieben, die an der Berechnung beteiligt sind.

Tabelle 9: JCut-Variablen für die Synchronisation zwischen Werkzeug und Werkstück

JCut-Variable Beschreibung

spindle_angle_per_tcard Winkelfenster des Werkzeugs pro Zeitkarte [°]

wp_angle_per_tcard Winkelfenster des Werkstücks pro Zeitkarte [°]

wp_number_of_teeth Zähnezahl

tangential_feed_per_tcard Tangentialvorschub des Werkzeugs pro Zeitkarte [mm]

wp_tang_feed_per_tcard_angle Tangentialvorschub des Werkstücks pro Zeitkarte als

Winkelfenster [°]

wp_diameter Durchmesser des Werkstücks [mm]

wp_outline_length Umfang des Werkstücks [mm]

wp_tang_feed_per_tcard Tangentialer Vorschub des Werkstücks bezogen auf den

Umfang [mm]

sync_offset Synchronisationsoffset [°]

Der Tangentialvorschub des Werkzeugs muss nun, auf den Außenradius des Werk-

stücks bezogen, in ein Winkelfenster umgerechnet werden. Dieses beschreibt die zu-

sätzliche Rotation des Werkstücks pro Zeitkarte, die dafür sorgt, dass sich die Zahnlü-

cke ebenfalls in tangentialer Richtung bewegt.

wp_outline_length Math. PI ∗ wp_diameter

wp_tang_feed_per_tcard tangential_feed_per_tcard

wp_outline_length

wp_tang_feed_per_tcard_angle wp_tang_feed_per_tcard ∗ 360

Das Winkelfenster des Werkstücks pro Zeitkarte (wp_angle_per_tcard) berechnet

sich wie folgt:

wp_angle_per_tcard spindle_angle_per_tcardwp_number_of_teeth

tangential_feed_angle_wp sync_offset

Die Variable sync_offset hat initial den Wert 0 und dient der manuellen Korrektur

des Synchronisationsverhältnisses. Dieser Wert kann durch den Benutzer über die

Benutzungsoberfläche bestimmt werden. Während der Simulation einer Zeile, wird zu

jeder Zeitkarte der Rotationswinkel pro Zeitkarte in angle_absolut_wp aufaddiert,

Implementierung 70

um am Ende den gesamten Rotationswinkel des Werkstücks einer simulierten Zeile zu

erhalten. Um genau diesen Betrag muss das Werkstück zurückrotiert werden, bevor

die nächste Zeile simuliert wird. So ist sichergestellt, dass das Synchronisationsver-

hältnis erhalten bleibt.

6.3.2 Kinematik und Visualisierung mit Java3D

Für die Umsetzung der Kinematik sowie der 3D-Visualisierung wird in JCut auf die Ja-

va3D-Klassen zurückgegriffen. Um ein dreidimensionales Objekt mit Java3D visualisie-

ren zu können, ist es notwendig, die geometrischen Informationen in eine Java3D-

Branchgroup-Struktur zu überführen. Dazu sind einige Zwischenschritte erforderlich.

Java3D stellt einige Grundkörper zur Verfügung (Box, Cone, Sphere etc.), die direkt

einer Branchgroup-Struktur als Kindelement hinzugefügt werden können. Möchte man

diese Objekte aber später im Raum verschieben oder rotieren, so ist ein weiterer Zwi-

schenschritt notwendig. Hierbei wird der Grundkörper zunächst einer Transformgroup

als Kindelement hinzugefügt, diese Transformgroup dann wiederum der Branchgroup.

Auf einer Transformgroup lassen sich nach dem Hinzufügen in das Java3D-Universum

Transformationen, sog. Transform3D-Methoden, ausführen. Dies können z.B. Rotation,

Translationen, Skalierungen etc. sein.

Die geometrischen Grundkörper, die JCut im Fall des Werkzeugs und des Werkstücks

visualisieren muss, sind 2D-Polygonlinien. Um diese in die dritte Dimension zu über-

führen, bedarf es einer zusätzlichen Struktur der Java3D-Klassen. Java3D stellt dafür

die Klasse Shape3D zur Verfügung, mit der beliebige Formen modelliert werden kön-

nen. JCut erweitert diese Klasse mit GenericShape2D. Diese Klasse erwartet bei der

Erzeugung eines Shape3D-Objektes eine JCutNodelist sowie eine Angabe der Tiefe

des 3D-Objektes (Extrudierung). So werden die 2D-Polygonzüge durch das Hinzufü-

gen einer Tiefeninformation zu 3D-Objekten. Diese Shape3D-Objekte können dann

einer Transformgroup und diese dann schließlich einer Branchgroup hinzugefügt wer-

den.

Bei diesem Vorgehen entstehen jedoch zwei wesentliche Probleme. Zum einen liegen

die geometrischen Informationen in einer neuen Struktur vor. Verkettungsinformatio-

nen, wie sie in den JCutNode-Listen vorlagen, sind darin nicht mehr enthalten. Man

kann zwar nach einer Transformation in einer Branchgroup auf die neuen Koordinaten

zugreifen, jedoch sind alle weiteren Informationen, die für eine Schnittberechnung not-

wendig sind, nicht mehr vorhanden. Zum anderen ist es bei der Schnittberechnung

erforderlich das Werkstück-Objekt geometrisch neu zu definieren.

Aus diesem Grund berechnet JCut die Kinematik vor der Visualisierung mit entspre-

chenden Methoden der Java3D-API. Hierbei wird auf die Point3D-Struktur zurückge-

griffen, mit der einzelne Punktkoordinaten über Java3D-Transformationen berechnet

werden. Entsprechende eigene Hilfsmethoden führen dies für JCutNode-Listen durch.

Für die Visualisierung der 3D-Objekte zu einer beliebigen Zeitkarte, wird dann die alte

Branchgroup aus dem Java3D-Universum entfernt und durch die neu berechnete er-

setzt. Durch dieses Vorgehen können alle Operationen des Schnittalgorithmus auf den

Implementierung 71

eigenen Datenstrukturen erfolgen. Zudem ist es möglich, zeitabhängig oder auch er-

eignisabhängig die Java3D-Visualisierung zu aktualisieren oder (ressourcenschonend)

ganz auf die Visualisierung während der Simulation zu verzichten.

Ergebnisse und Bewertung 72

7 Ergebnisse und Bewertung

Im Rahmen dieser Arbeit ist der experimentelle Software-Prototyp JCut entstanden.

Dieser kann Durchdringungsrechnungen für den Analogieprozess des Axial-

Wälzfräsens, dem Schlagzahnfräsen, durchführen. JCut verwendet dabei das Poly-

gonmodell für die Diskretisierung des Werkzeugs sowie des Werkstücks. Alle notwen-

digen Simulationsparameter können durch den Benutzer angepasst werden. Die Funk-

tionalität von JCut ist so gekapselt, dass Ergänzungen sowie Anpassungen am Pro-

gramm leicht möglich sind.

Im Folgenden soll JCut kurz vorgestellt werden und anschließend die Funktionalität

evaluiert werden. Dabei wird überprüft, ob alle Anforderungen erfüllt werden. Ferner

werden die Ergebnisse einer Versuchsreihe15 vorgestellt, bei denen mit JCut durchge-

führte Durchdringungsrechnungen analytischen Ergebnissen gegenüberstellt werden.

7.1 JCut

7.1.1 Benutzungsoberfläche

Abbildung 22: JCut-Benutzungsoberfläche

Die JCut-Benutzungsoberfläche ist logisch in die folgenden Bereiche gegliedert:

15 Mit stark vereinfachter Geometrie von Werkzeug und Werkstück.


Werkzeugparameter

Werkstückparameter

Allgemeine Parameter

Errechnete Kenngrößen

Steuerungsschaltflächen sowie Simulationsoptionen

Anwendungsmenü für weitere Funktionen (z.B. Werkzeugprofil einlesen)

Darüber hinaus gibt es ein Menü „Ansicht“ welches in der vorliegenden Version nur

eine Ansicht anbietet. Die Idee dahinter ist, dass weitere Prozesse oder Variationen,

die zu einem späteren Zeitpunkt implementiert werden, hier entsprechend auswählbar

gemacht werden können. Die Funktionalität hinter den einzelnen Simulationsparame-

tern entspricht der Beschreibung aus dem Systementwurf (vgl. dazu Kapitel 5.2.2).

JCut öffnet beim Start der Anwendung drei Fenster. Das Hauptfenster beinhaltet die

3D-Visualisierung, ein zweites Fenster enthält die 2D-Visualisierung und das dritte die

in Abbildung 22 vorgestellte Benutzungsoberfläche.

7.1.2 2D-Visualisierung

Die 2D-Visualisierung hat während der Entwicklung wertvolle Dienste geleistet. Sie

kann in einer Schnittebene das aktuelle Werkzeug-Polygon (blau), das aktuelle Werk-

stück-Polygon (schwarz) sowie die Spanungsquerschnitte (rot) visualisieren. Abbildung

23 zeigt exemplarisch alle drei Typen der Polygonzüge aus einer Durchdringungsrech-

nung für die Evaluation in Kapitel 7.3.3. Da die Auswertung der einzelnen Schnittebe-

nen in der aktuellen Version nur in den exportierten Ergebnisdateien möglich ist, hat

dieses Modul ein wenig an Bedeutung verloren. Die Entscheidung, die 2D-

Visualisierung dennoch nicht zu verwerfen, ist aufgrund der Erweiterungsmöglichkeiten

gefällt worden. Für zukünftige Erweiterungen, die im Ausblick vorgeschlagen werden,

ist dieses Modul wieder sinnvoll einsetzbar. Außerdem lässt sich das Fenster der 2D-

Visualisierung problemlos schließen, ohne dass dadurch die Funktionalität des restli-

chen Programms beeinträchtigt wäre.


Abbildung 23: JCut-2D-Visualisierung

7.1.3 3D-Visualisierung

Die 3D-Visualisierung in JCut war ursprünglich nur als Wunschkriterium geplant. Bei

der Implementierung der Kinematik hat sich jedoch herausgestellt, dass die 3D-

Visualisierung ein sehr hilfreiches Instrument beim Testen ist. Aus diesem Grund ist die

Einstufung als Wunschkriterium zu hinterfragen. Das Programm wäre zwar auch ohne

die 3D-Visualisierung lauffähig und würde Ergebnisse liefern, hätte dann aber auch

sehr wahrscheinlich einen geringeren Funktionsumfang. Zudem wertet dieses Modul

die Anwendung für Benutzer deutlich auf. Durch die Visualisierung bekommt der Be-

nutzer, nach dem Einlesen der Simulationsparameter, eine direkte visuelle Rückmel-

dung über deren Auswirkung. Darüber hinaus kann die 3D-Visualisierung während der

Durchdringungsrechnung den aktuellen Status darstellen. Hierbei ist aber zu beachten,

dass die CPU-Zeit einer Durchdringungsrechnung durch kontinuierliche 3D-

Vislualisierung erheblich ansteigt. Um in einem solchen Fall dem Simulationsverlauf

folgen zu können, kann in JCut über die Benutzungsoberfläche eine künstliche Verzö-

gerung in Millisekunden eingestellt werden.

Die 3D-Visualisierung zeigt aus einer vorgegebenen Kameraperspektive direkt auf die

simulierte 3D-Szene in dem Java3D-Universum. Dabei kann der Benutzer die Ansicht

durch verschiedene Mausaktionen verändern:

Rotationen: In die Szene mit der linken Maustaste klicken und dann bei ge-

drückter Maustaste ziehen. Die Rotation ist in alle Maus-

Richtungen möglich.

Zoomen: Betätigung des Mausrads.

Verschieben: In die Szene mit der rechten Maustaste klicken und dann bei

gedrückter Maustaste ziehen.

Die JCut-Benutzungsoberfläche verfügt über eine Schaltfläche, mit der die Ansicht auf

den Initialzustand zurückgesetzt werden kann. Daneben gibt es in der Benutzungs-


oberfläche vier Schaltflächen mit Richtungspfeilen. Diese verschieben die Schneide um

den Betrag, der über den Simulationsparameter „Manueller Vorschubweg“ eingestellt

werden kann. Dies kann z.B. hilfreich sein, wenn die Schneide nach der Simulation in

einer ungünstigen Position stehen bleibt und somit die Sicht einschränkt. Das Ver-

schieben der Schneide bezieht sich ausschließlich auf die aktuelle Ansicht und wird bei

einer Simulation, die anschließend gestartet wird, nicht berücksichtigt.

Abbildung 24: JCut-3D-Visualisierung

7.1.4 Export der Ergebnisse

Die Simulationsergebnisse werden in einem Verzeichnis gespeichert, welches durch

den Benutzer festgelegt werden kann. Dies kann ein beliebiges Verzeichnis in einem

eingebundenen Dateisystem sein. Die exportierten Ergebnisse liegen im CSV-Format

vor, welches eine einfache Weiterverarbeitung, z.B. in einer Tabellenkalkulation, er-

möglicht. In den Ergebnisdateien werden die Ergebnisse nebeneinander ausgegeben.

Dabei sind die Spalten16 A-D für die Knotennummern und XYZ-Koordinaten der Werk-

stückkontur der jeweiligen Schnittebene bestimmt. Die Spalten F-I enthalten analog die

Informationen für die Werkzeugkontur in der jeweiligen Schnittebene. Bei einem detail-

16 Beschriftung der Spalten am Beispiel von Microsoft Excel.


lierten Export werden in den Spalten J-O zusätzliche Informationen ausgegeben (Win-

kel und Richtungsvektor). Jeder Knoten der Werkzeugschneide in der Schnittebene

wird durch zwei Knoten der Trajektorie der simulierten Schneide bestimmt. Dabei wird

zwischen diesen beiden Knoten, von denen einer über der Schnittebene liegt, und ei-

ner darunter, linear interpoliert. Anhand der Geraden zwischen diesen beiden Knoten

wird der Schnittpunkt mit der jeweiligen Schnittebene errechnet. Dieser berechnete

Knoten in der Schnittebene wird in der CSV-Datei, zusammen mit den Rotationswin-

keln der beiden Knoten, aus denen er entstanden ist, ausgegeben. In den Spalten K-

N, P-S17 usw. werden, je nach deren Anzahl, die Spanungsquerschnitte ausgegeben.

Zusätzlich wird bei den Spanungsquerschnitten in der ersten Zeile die Fläche des

Polygons ausgegeben.

Aufgrund der Größe befinden sich Ergebnisse einer beispielhaft durchgeführten Simu-

lation auf dem beiliegenden Datenträger.

7.2 Test des Prototyps

Jeder einzelne Schritt der Kinematik wurde während der Entwicklung anhand der ex-

portierten Ergebnisdaten überprüft. Ebenso wurde der Schnittalgorithmus auf diese

Weise getestet. Beispiele hierfür befinden sich ebenfalls auf dem beiliegenden Daten-

träger. An dieser Stelle soll darauf hingewiesen werden, dass die Algorithmen nur

durch Testen auf Plausibilität geprüft wurden, eine Verifikation der Algorithmen ist auf-

grund des enormen zeitlichen Aufwands nicht durchgeführt worden.

7.3 Evaluation

7.3.1 Anforderungen

Von den funktionalen Muss-Kriterien sind alle umgesetzt worden. Bei den Wunschkrite-

rien sind, bis auf die folgenden Ausnahmen, ebenfalls alle Anforderungen erfüllt.

Die folgenden Wunschkriterien sind in der vorliegenden Arbeit nicht umgesetzt worden:

F110: Mehrschnittstrategie

Wird nach einer Durchdringungsrechnung eine Weitere gestartet, so wird dabei das

Werkstück neu initialisiert.

F120: Gangzahl > 1

JCut unterstützt in der vorliegen Version nur die Gangzahl=1.

Das folgende Wunschkriterium ist nur teilweise umgesetzt.

F030: Importieren der Werkstückgeometrie.

17 Bei einem detaillierten Export entsprechend in den Spalten Q-T, V-Y usw.


JCut kann über Simulationsparameter das Werkstück variieren (Durchmesser, Höhe

der Schnittebenen, Initialposition, Anzahl der Knoten). Beliebige Polygonzüge, z.B.

Ergebnisse aus vorigen Simulationen, die weiter bearbeitet werden sollen, sind in der

vorliegenden Version nicht möglich.

7.3.2 Genauigkeit der Durchdringungsrechnung

Generell sind computergestützte Simulationen immer mit dem Genauigkeitsproblem

konfrontiert. Dies ist auch bei JCut nicht anders. Bei der Durchdringungsrechnung tre-

ten an verschiedenen Stellen Ungenauigkeiten auf. Im Folgenden werden diese Stellen

beschrieben.

Rundungsfehler bei arithmetischen und trigonometrischen Rechenoperationen

JCut verwendet für alle Koordinaten den Datentyp double. Dieser bietet eine Genauig-

keit von 17 signifikanten Stellen. Dabei bilden die Ziffern vor und nach dem Komma

zusammen die signifikanten Stellen. Bei JCut werden alle Größen in Millimeter ange-

nommen, wobei bei konsistenter Umrechnung auch andere Einheiten möglich wären.

Unter der Annahme, dass vier signifikante Ziffern vor dem Komma ausreichend sind

(Abmessungen bis 9999 mm), verbleiben für die Nachkommastellen 13 signifikante

Stellen. In JCut ist in der Variable cut_precision hinterlegt, welche Genauigkeit für

arithmetische und trigonometrische Berechnungen gefordert ist. Dieser Wert beträgt

0,0000005 und ist nicht über die Benutzungsoberfläche veränderbar. Bei Berechnun-

gen wird dieser Genauigkeitswert für Abfragen benutzt. Die Abfrage gilt als erfüllt,

wenn das Ergebnis nicht mehr als cut_precision abweicht. Ebenso kann dieser

Wert so interpretiert werden, dass Berechnungen in JCut nur für 6 signifikante Stellen

nach dem Komma genau sind. Die durch Rundungsfehler zu erwartenden Ungenauig-

keiten sollten ab der 13. signifikanten Stelle oder später auftreten.

Der Datentyp double führt allerdings nicht nur bei Rechenoperationen zu Rundungs-

fehlern. Allein die Repräsentation der Zahlen im Speicher führt schon zu den Unge-

nauigkeiten, wie sie auch bei der Rundung auftreten. In Java sind die Datentypen float

und double nach IEEE754 im Speicher repräsentiert (vgl. [IEEE754], Seite 9). Hierbei

wird die nächste binär passende Repräsentation der Zahl gewählt. Dies führt dazu,

dass einfache Fließkommazahlen wie z.B. 0,1 schon einen Rundungsfehler an der

letzten signifikanten Stelle in der internen Repräsentation haben.

Dieses Problem, welches durch die Darstellung der Fließkommazahlen vom Typ float

und double verursacht wird, kann generell durch die Verwendung eines anderen Da-

tentyps gelöst werden. Java stellt hierfür den Datentyp BigDecimal zur Verfügung. Die-

ser hat keine Begrenzung in der Genauigkeit und wird intern als String repräsentiert.

Dabei beansprucht er allerdings eine deutlich höhere CPU-Zeit für arithmetische Ope-

rationen. Bei Multiplikation von zwei Fließkommazahlen beträgt der Faktor zwischen

den jeweils benötigten CPU-Zeiten ungefähr 1500 (vgl. [Aenderl 2009]). In JCut findet

eine sehr hohe Zahl von arithmetischen und trigonometrischen Operationen statt. Aus

diesem Grund wurde bewusst double anstelle von BigDecimal als Datentyp gewählt.


Die geforderte Genauigkeit von 6 Stellen nach dem Komma lässt sich damit erfüllen.

Dabei ist die benötigte Rechenzeit um ein Vielfaches kleiner.

Diskretisierung Werkzeug

In JCut wird das Werkzeug als zweidimensionaler Polygonzug repräsentiert. Hierbei ist

die Auflösung der Diskretisierung, also die Abstände zwischen den einzelnen Knoten,

ein entscheidender Faktor für die Genauigkeit der zu erwartenden Ergebnisse. Das

Polygonmodell interpoliert zwischen zwei Knoten linear in Form einer Kante. Der Ab-

stand zwischen zwei Knoten kann durch den Benutzer bestimmt werden, indem ein

beliebiges Schneidprofil importiert wird. Ansonsten wird eine Standardschneide ver-

wendet. Die Definition dieser Standardschneide befindet sich auf dem beiligenden Da-

tenträger.

Diskretisierung Werkstück

Das Werkstück wird analog zum Werkzeug ebenfalls in Polygonlinien abgebildet. Da-

bei wird die Auflösung der Diskretisierung über die Benutzungsoberfläche bestimmt

und ist somit nicht beliebig. Der Benutzer kann dabei den Radius sowie die Anzahl der

Knoten auf der Werkstückkontur bestimmen. Ferner gibt es bei dem Werkstück mit der

Höhe und Anzahl der Schnittebenen zwei weitere Diskretisierungsgrößen. Die Höhe

der Schnittebene multipliziert mit der Anzahl der Schnittebenen ergibt dabei die Ge-

samthöhe des Werkstücks. Die Höhe ist dabei eine weitere Diskretisierungsgröße, die

durch den Benutzer veränderbar ist. Hierbei liefert jede Schnittebene für die jeweilige

Z-Position Ergebnisse. Für die Bereiche zwischen den Schnittebenen werden keine

Simulationsergebnisse berechnet. Der Benutzer kann dies aber durch die Erhöhung

der Anzahl der Schnittebenen bei gleichzeitiger Reduktion der entsprechenden Höhe

erreichen.

Diskretisierung der Zeitachse

Die Zeitachse ist in JCut eine weitere Größe, deren Diskretisierung direkt durch den

Benutzer bestimmt wird. Hierbei gibt der Benutzer eine Schrittweite zwischen zwei

Zeitkarten vor. Dies hat zur Folge, dass Positionen von Werkzeug und Werkstück nur

zu diesen Zeitpunkten berechnet werden, nicht aber dazwischen.

Diskretisierung der Kinematik

Bei der Aufzeichnung der Bahn des Werkzeugs liefert die Zeitkartenschrittweite zu-

sammen mit der Drehgeschwindigkeit des Werkzeugs ein Winkelfenster. Die Bahn des

Werkzeugs wird also nur zu den Winkelpositionen der jeweiligen Zeitkarte aufgezeich-

net. Zwischen diesen Positionen findet eine lineare Interpolation statt, um den Schnitt-

punkt mit den Schnittebenen zu bestimmen. Je größer dieses Winkelfenster ist, desto

größer sind auch die Abweichungen im Ergebnis.

Modellbedingte Fehler

Neben den oben genannten Faktoren gibt es noch einen weiteren, der allerdings durch

das Simulationsmodell bedingt ist. Hierbei handelt es sich um die Bestimmung der

Spanungsquerschnitte. Das Problem entsteht hierbei durch die Tatsache, dass die


Werkzeugschneide zu einer gegebenen Werkzeugrotation nicht in einer Schnittebene

des Werkstücks liegt. Dies ist zwar auch möglich, aber in der Regel wird die Schneid-

fläche des Werkzeugs durch den Neigungswinkel und/oder den aktuellen Rotations-

winkel leicht schräg im Raum stehen. In der Durchdringungssimulation wird dagegen

bestimmt, wo die Schneide die Schnittebene, welche parallel zu einer Z-Ebene verläuft,

durchdrungen hat. Diese Kontur in der Schnittebene wird dann mit dem Werkstück-

polygon der Schnittebene auf Schnittflächen untersucht. Diese Schnittflächen weichen

aber durch deren Lage im Raum von der realen Schnittfläche (Spanungsquerschnitte)

ab.

7.3.3 Aussagekraft der simulierten Spanungsquerschnitte

Die Abweichungen der simulierten Spanungsquerschnitte zu beziffern, ist nicht trivial.

An diesen Abweichungen sind diverse Simulationskenngrößen beteiligt. Da die Arbeit

auf dem Modell von Gerd Sulzer [Sulzer 1973] aufbaut, wurde die Dissertation zur Be-

antwortung dieser Frage herangezogen. Sulzer weist auf S. 35 darauf hin, dass die

simulierten Spanungsquerschnitte, basierend auf der „virtuellen Schneidkontur“ statt

der tatsächlichen Schneidkontur, geringfügig verzerrt sind. Eine Quantifizierung dieser

Verzerrung findet jedoch nicht statt.

Um diese Abweichung abschätzen zu können, wird anhand einer analytischen Formel

sowie einer angepassten Durchdringungsrechnung mit JCut ein Vergleich durchge-

führt. Dabei werden einige an der Abweichung beteiligten Parameter auf ihren Einfluss

untersucht.

Abbildung 25: Geometrisches Modell für die analytische Untersuchung


Abbildung 25 zeigt den Aufbau der Untersuchung. Dabei wurde das Werkstück als

rechteckiger Block angenommen und auf die Werkstückrotation verzichtet, analog wird

bei dem Werkzeug auf den Tangentialvorschub verzichtet. Tabelle 10 zeigt die durch-

geführten Variationen. Der Radius des Werkzeugs (30 mm) ist ebenso wie die Länge

der Schneidfläche (10 mm) für alle Variationen konstant. Daraus ergibt sich ein Kopf-

kreisdurchmesser von 80 mm, welcher eine realistische Größe für diesen Prozess dar-

stellt. Eine Variation dieser Kenngröße wäre eine sinnvolle Ergänzung zu der hier

durchgeführten Untersuchung.

Tabelle 10: Analytischer Vergleich / Variationen

Variationsindex

Breite der

Schneidfläche

[mm]

Tauchtiefe der

Schneidfläche

[mm]

Winkelfenster der

Schneide pro

Zeitkarte [°]

Neigungswinkel

der Schneidflä-

che [°]

01 10 5,0 0,15 0

02 2,5 5,0 0,15 0

03 1,0 5,0 0,15 0

04 0,5 5,0 0,15 0

05 0,1 5,0 0,15 0

06 10 2,5 0,15 0

07 2,5 2,5 0,15 0

08 1,0 2,5 0,15 0

09 0,5 2,5 0,15 0

10 0,1 2,5 0,15 0

11 1,0 5,0 1,50 0

12 1,0 5,0 5,00 0

13 1,0 5,0 0,15 15

14 1,0 5,0 0,15 30

15 0,1 5,0 0,15 15

16 0,1 5,0 0,15 30

Die Variationen 01 - 10 variieren die Breite der Schneidfläche sowie die maximale

Tauchtiefe in das Werkstück. Dabei entstehen unterschiedliche Spanungsquerschnitte.

Die Untersuchung hat aber gezeigt, dass die Abweichungen zwischen analytischen

sowie den simulierten Spanungsquerschnitten in allen Variationen (01 - 10) identisch

ist. Dies ist darauf zurückzuführen, dass sowohl das Winkelfenster der Schneide pro

Zeitkarte als auch der Neigungswinkel in diesen Variationen konstant sind. Die Tabelle

11 zeigt die Variation 01 stellvertretend für die Variationen 01 - 10.

Eine wesentliche Schwierigkeit bei dem simulierten Ansatz ist die Tatsache, dass die

Schneidfläche in den Schnittebenen des Werkstücks anhand der Trajektorie der ein-

zelnen Knoten beschrieben wird. Zu einem Rotationswinkel des Werkzeugs steht die

Schneidfläche, mit einer Ausnahme (Rotationswinkel = 0°), schräg im Raum. Die ein-

zelnen Knoten der Schneidfläche durchdringen die Schnittebene zu unterschiedlichen

Zeitpunkten, was gleichbedeutend mit unterschiedlichen Rotationswinkeln des Werk-

zeugs ist. Die einzelnen Knoten der Schneidkontur in der jeweiligen Schnittebene sind


also zu unterschiedlichen Rotationswinkeln des Werkzeugs entstanden. Aus diesem

Grund kann die Fläche eines simulierten Spanungsquerschnittes nicht eindeutig einem

Rotationswinkel zugewiesen werden. In der durchgeführten Untersuchung wurden hier-

für zwei Ansätze verfolgt. Zum einen wurde der Durchschnittswert aller Knoten der

Werkzeugschneide in der Schnittebene gewählt und zum anderen nur die an dem

Spanungsquerschnitt beteiligten Knoten für die Berechnung des Durchschnittswinkels

herangezogen. In Tabelle 11 und

Tabelle 12 sind diese beiden Varianten immer paarweise für eine Schnittebene darge-

stellt. Die an dem Durchschnittswinkel beteiligten Knoten sind durch Fettdruck markiert.

Die daraus resultierenden Winkel weichen von einander ab. Dieser Effekt verstärkt sich

mit einem zunehmenden Rotationswinkel.

Tabelle 11: Vergleich analytischer und simulierter Spanungsquerschnitte (Variation

01)

Sch

nitte

bene

Z-K

oord

iant

e

D

urch

schn

ittlic

her

Win

kel d

er S

chne

ide

[°]

(bet

eilig

te W

inke

l sin

d

durc

h F

ettd

ruck

mar

kier

t)

Win

kel v

on K

note

n 1

[°]

Win

kel v

on K

note

n 2

[°]

Win

kel v

on K

note

n 3

[°]

Win

kel v

on K

note

n 4

[°]

Spa

nun

gsqu

ersc

hnitt

e

ana

lytis

ch b

ere

chne

t

[mm

²]

Spa

nun

gsqu

ersc

hnitt

aus

der

Sim

ulat

ion

[mm

²]

Diff

eren

z in

% z

wis

chen

ana

lytis

chem

SQ

und

sim

ulie

rtem

SQ

36 0,075 0,075 0,075 0,075 0,075 49,99970014 50,000 0,00%

36 0,075 0,075 0,075 0,075 0,075 49,99970014 50,000 0,00%

34 2,924 3,825 2,924 2,924 3,825 49,54373301 49,49955643 0,09%

34 3,375 3,825 2,924 2,924 3,825 49,3919089 49,49955643 -0,22%

32 5,775 7,725 5,775 5,775 7,725 48,21458639 47,99470901 0,46%

32 6,75 7,725 5,775 5,775 7,725 47,55702636 47,99470901 -0,92%

30 8,625 11,475 8,625 8,625 11,475 45,99658953 45,47405228 1,14%

30 10,05 11,475 8,625 8,625 11,475 44,54585524 45,47405228 -2,08%

28 11,475 15,525 11,475 11,475 15,525 42,86137094 41,91824781 2,20%

28 13,5 15,525 11,475 11,475 15,525 40,05468222 41,91824781 -4,65%

26 14,475 19,425 14,475 14,475 19,425 38,52564625 37,29798109 3,19%

26 16,95 19,425 14,475 14,475 19,425 34,10536671 37,29798109 -9,36%

24 17,475 23,625 17,475 17,475 23,625 33,06525234 31,57534062 4,51%

24 20,55 23,625 17,475 17,475 23,625 26,21462321 31,57534062 -20,45%

22 20,475 27,825 20,475 20,475 27,825 26,39763585 24,69952396 6,43%

22 24,15 27,825 20,475 20,475 27,825 16,42889579 24,69952396 -50,34%

20 23,625 32,175 23,625 23,625 32,175 17,98231762 16,60582733 7,65%

20 27,9 32,175 23,625 23,625 32,175 3,967400311 16,60582733 -318,56%

18 26,775 36,825 26,775 26,775 36,825 7,967211094 7,211105062 9,49%

18 31,8 36,825 26,775 26,775 36,825 -18

7,211105062 -

18 Für den zugehörigen Winkel gibt es nach der analytischen Rechnung keinen Schnitt.


Abbildung 26: Abweichung der Spanungsquerschnitte in Variation 01

Die Variationen 11 und 12 führen durch die Vergrößerung des Winkelfensters erwar-

tungsgemäß zu einer zusätzlichen Abweichung der Rotationswinkel. Dabei ist diese

Abweichung in Variation 12 so groß, dass Spanungsquerschnitte in zwei benachbarten

Schnittebenen des Werkstücks einem identischen Rotationswinkel des Werkzeugs

zugeordnet werden. Dies führt nicht zu sinnvollen Ergebnissen. Aus diesem Grund

wurde Variation 12 nicht weiter ausgewertet.

Die Variationen 13 - 16 variieren den Neigungswinkel der Werkzeugschneide sowie

deren Breite. Die Breite der Schneide hat hierbei jedoch nur einen sehr geringen Anteil

an den Abweichungen. Stellvertretend für diese Variationen, zeigt

Tabelle 12 mit einem Neigungswinkel von 30° die größten Abweichungen. Bei einem

Neigungswinkel von 15° sind die Abweichungen in etwa um Faktor 5 kleiner.


Tabelle 12: Vergleich analytischer und simulierter Spanungsquerschnitte (Variation

16)

Sch

nitte

bene

Z-K

oord

iant

e

D

urch

schn

ittlic

her

Win

kel d

er S

chne

ide

[°]

(bet

eilig

te W

inke

l sin

d

durc

h F

ettd

ruck

mar

kier

t)

Win

kel v

on K

note

n 1

[°]

Win

kel v

on K

note

n 2

[°]

Win

kel v

on K

note

n 3

[°]

Win

kel v

on K

note

n 4

[°]

Spa

nun

gsqu

ersc

hnitt

e

ana

lytis

ch b

ere

chne

t

[mm

²]

Spa

nun

gsqu

ersc

hnitt

aus

der

Sim

ulat

ion

[mm

²]

Diff

eren

z in

% z

wis

chen

ana

lytis

chem

SQ

und

sim

ulie

rtem

SQ

36 0,000 0,075 0,075 359,925 359,925 0,5 0,577347343 -15,47%

36 0,000 0,075 0,075 359,925 359,925 0,5 0,577347343 -15,47%

34 3,300 4,425 3,375 3,225 4,425 0,494186719 0,569639063 -15,27%

34 3,8625 4,425 3,375 3,225 4,425 0,492031935 0,569639063 -15,77%

32 6,6 8,925 6,675 6,525 8,775 0,476649933 0,546444656 -14,64%

32 7,725 8,925 6,675 6,525 8,775 0,467945343 0,546444656 -16,78%

30 9,975 13,425 9,975 9,975 13,275 0,446279933 0,507525833 -13,72%

30 11,6625 13,425 9,975 9,975 13,275 0,426220483 0,507525833 -19,08%

28 13,35 17,925 13,425 13,275 17,925 0,402795424 0,452474709 -12,33%

28 15,6375 17,925 13,425 13,275 17,925 0,365472896 0,452474709 -23,81%

26 16,8 22,725 16,875 16,725 22,575 0,343958303 0,380689872 -10,68%

26 19,725 22,725 16,875 16,725 22,575 0,281830333 0,380689872 -35,08%

24 20,25 27,525 20,325 20,175 27,375 0,269417691 0,291338528 -8,14%

24 23,85 27,525 20,325 20,175 27,375 0,173220423 0,291338528 -68,19%

22 23,85 32,625 23,925 23,775 32,475 0,173220423 0,183306504 -5,82%

22 28,2 32,625 23,925 23,775 32,475 0,028609678 0,183306504 -540,72%

20 27,525 38,025 27,525 27,525 37,875 0,053266348 0,055117642 -3,48%

20 32,7375 38,025 27,525 27,525 37,875 -18 0,055117642 -

18 -19

- - - -

18 - - - - -

19 Aufgrund des Neigungswinkels in Variation 16 gibt es in Schnittebene 18 keinen Schnitt.


Abbildung 27: Abweichung der Spanungsquerschnitte in Variation 16

Bei allen Variationen erwies sich für die Zuordnung der Spanungsquerschnitte anhand

des Durchschnittswinkels aller Knoten der Schneidfläche als nachteilhaft (vgl. Abbil-

dung 26 und Abbildung 27). Die modellbedingten Abweichungen zu den analytisch

berechneten Spanungsquerschnitten waren dabei, besonders mit zunehmendem Rota-

tionswinkel, um ein Vielfaches größer. Die Abweichungen in der durchgeführten Unter-

suchung liegen zwischen 0 und 15%, sofern die Zuordnung zu einem Rotationswinkel

nur anhand der Knoten erfolgt, die an dem Spanungsquerschnitt beteiligt sind.

Die vollständigen Auswertungen befinden sich auf dem beiliegenden Datenträger.

Zusammenfassung und Ausblick 85

8 Zusammenfassung und Ausblick

Das Ziel dieser Diplomarbeit war die Entwicklung eines Software-Prototyps für die

Durchführung von Durchdringungsrechnungen. Dabei sollte exemplarisch an dem Pro-

zess des Wälzfräsens die Funktionalität demonstriert werden. Für die Simulation wurde

ein Analogieprozess für das Axialwälzfräsen ausgewählt. Ziel der Durchdringungsrech-

nungen war dabei nicht nur die Bestimmung des Zahnrads, sondern insbesondere die

Bestimmung der Spanungsquerschnitte, die dabei entstehen.

Bei der Suche nach bestehenden Lösungen wurden Produkte gefunden, die nur an-

hand von Erwähnungen in der entsprechenden Literatur beschrieben werden konnten.

Da diese Software-Lösungen jedoch nicht verfügbar sind, konnten sie nicht für die Un-

tersuchungen in dieser Arbeit verwendet werden. Die Dissertation von Gerd Sulzer aus

dem Jahr 1973 war jedoch eine wertvolle Basis für die Entwicklung des eigenen Soft-

ware-Prototyps JCut.

An JCut wurden diverse Anforderungen gestellt, welche dann in einem Softwareent-

wurf konkretisiert wurden. Hierfür wurden geeignete Algorithmen sowie ein

Diskretisierungsmodell ausgewählt. Die anschließend erfolgte Implementierung setzt

alle funktionalen Muss-Kriterien um. Von den formulierten Wunschkriterien wurden, bis

auf zwei Ausnahmen, ebenfalls alle umgesetzt. JCut wurde dabei als experimenteller

Prototyp konzipiert, welcher Ergänzungen, Anpassungen und Erweiterungen ermög-

licht. Dabei ist hervorzuheben, dass JCut auf keiner Fremdsoftware aufbaut oder diese

voraussetzt. Außerdem ist JCut auf den verschiedenen Plattformen und Betriebssys-

temen einsetzbar, da ausschließlich in Java programmiert wurde. Als besonders hilfrei-

ches Modul hat sich die 3D-Visualisierung herausgestellt. Diese war eine große Ar-

beitserleichterung beim Testen der Anwendung. Ebenso ist sie für den Benutzer ein

wertvolles Element, um die zahlreichen Simulationsparameter visuell zu erfassen.

Eine erste Frage konnte im Rahmen dieser Arbeit bereits mit JCut beantwortet werden.

Dabei wurde die Abweichung der simulierten Spanungsquerschnitte von analytisch

bestimmten Spanungsquerschnitten untersucht. Dieses Ergebnis soll die zukünftige

Arbeit mit JCut unterstützen und Anregung sein, JCut um weitere Verfahren und Mo-

delle zu ergänzen und diese qualitativ mit den vorliegenden Ergebnissen zu verglei-

chen.

8.1 Ausblick

Während der Entwicklung entstanden zahlreiche Ideen für eine sinnvolle Erweiterung

von JCut. Neben der Möglichkeit, weitere Durchdringungsrechnungen abzubilden, Va-

riationen für die Schnittalgorithmen sowie weitere Diskretisierungsmodelle zu imple-

mentieren, soll an dieser Stelle eine Auswahl grundlegender Erweiterungsansätze vor-

gestellt werden.

Zusammenfassung und Ausblick 86

Sinnvoll wäre eine binäre Ergebnisspeicherung, welche einen selektiven Export in das

CSV-Format sowie selektives Auswerten von Ergebnissen in JCut ermöglichen würde.

Ebenso sinnvoll wäre die Erweiterung der Importfunktion für weitere Geometriedaten-

formate sowie die Möglichkeit, die Geometriedaten für das Werkstück zu importieren.

Analog zu dem Importmodul könnte auch ein Exportmodul entwickelt werden, dass die

Daten neben dem CSV-Format in weitere gängige CAD- und 3D-Formate exportieren

kann.

Für das Werkzeug wäre eine Funktion zur Bestimmung der Werkzeugschneidkontur

anhand entsprechender Kenngrößen sinnvoll und würde neben der bestehenden Im-

portfunktion eine praktische Ergänzung darstellen. Die Beschränkung auf Schlagzahn-

prozesse mit der Gangzahl = 1 könnte aufgehoben werden, so dass hier auch mehrere

Gänge simuliert werden können. Als letzter Punkt soll noch die Implementierung von

einem Batch-Modus angeregt werden. Dabei könnten Simulationsparameter in Konfi-

gurationsdateien (z.B. im XML-Format) abgespeichert werden, um dann mehrere Si-

mulationen nacheinander über eine entsprechende Stapelverarbeitungsdatei durchzu-

führen.

Anhang A: Inhaltsverzeichnis der CD 87

Anhang A: Inhaltsverzeichnis der CD

Die nachstehende Tabelle führt die Verzeichnisse des beiliegenden Datenträgers auf.

Ordnername auf dem Datenträger Beschreibung

/src Der dokumentierte Quellcode, welcher im

Rahmen dieser Arbeit entstanden ist.

/pdf Enthält eine digitale Version dieser Arbeit

im PDF-Format.

/simulationsergebnisse Beispiel einer durchgeführten Durchdrin-

gungsrechnung.

/evaluationsergebnisse Die Ergebnisse der durchgeführten Eva-

luation der simulierten Spanungsquer-

schnitte.

/beispiele Beispiele der Import- und Exportdateien.

/software Die Java-Laufzeitumgebung sowie die

verwendete Java3D Version.

/hilfe Eine Berechnungshilfe zur Bestimmung

der tangentialen Vorschubgeschwindig-

keit.

Anhang B: Simulationsdaten 88

Anhang B: Simulationsdaten

B1: Beispiel eines exportierten JCut-Ergebnisses im CSV-Format

Werkstück;;;;;Werkzeug;;;;;Spanungsquerschnitt: 0;10;Fläche:;0,08963489853444262

wp_n_nr;wp x_coor;wp y_coor;wp z_coor;;tl_n_nr;tl x_coor;tl y_coor;tl z_coor;;sw0_n_nr;sw0 x_coor;sw0 y_coor;sw0 z_coor

2653;120,0;70,0;10,0;;115;74,99989675001379;79,32991752071155;10,0;;144;80,78312400694824;77,47927205988464;10,0

2654;119,97881957591903;70,09773121116459;10,0;;116;76,24988814584827;78,92991752071154;10,0;;120;81,24985372918621;77,32991752071155;10,0

2655;159,09248446594322;78,47216963237322;10,0;;117;77,49987954168276;78,52991752071155;10,0;;121;82,4998451250207;76,92991752071154;10,0

2656;159,85493271476048;73,40357728010395;10,0;;118;78,74987093751724;78,12991752071154;10,0;;122;83,39983893002153;76,42991752071154;10,0

2657;159,96296407025147;68,27909828299333;10,0;;119;79,99986233335173;77,72991752071155;10,0;;123;83,99983480002209;76,17991752071154;10,0

2658;159,41480466054315;63,18287644449613;10,0;;120;81,24985372918621;77,32991752071155;10,0;;2760;83,99983480002209;76,13904913393219;10,0

2659;158,21945524799148;58,198591586313704;10,0;;121;82,4998451250207;76,92991752071154;10,0;;2709;83,44478420269039;76,37505955561258;10,0

2660;156,3965434368997;53,40808552801454;10,0;;122;83,39983893002153;76,42991752071154;10,0;;2708;82,54844844597639;76,8815680852583;10,0

2661;153,97600138881245;48,890018246639436;10,0;;123;83,99983480002209;76,17991752071154;10,0;;2707;81,3014040028238;77,29061544060811;10,0

2662;150,9975743372363;44,71857628203532;10,0;;124;83,99983480002209;74,47991752071155;10,0;;2706;80,78007088512706;77,46161971733775;10,0

2663;147,510167972018;40,96225459593775;10,0;;125;83,39983893002153;74,22991752071155;10,0;;;;;

2664;143,57104540925891;37,682731886583454;10,0;;126;82,4998451250207;73,72991752071155;10,0;;;;;

2665;139,24488693253707;34,9338578261923;10,0;;127;81,24985372918621;73,32991752071155;10,0;;;;;

2666;134,60272794443458;32,76076885084013;10,0;;128;79,99986233335173;72,92991752071154;10,0;;;;;

2667;129,72079256720133;31,19914702142264;10,0;;129;78,74987093751724;72,52991752071155;10,0;;;;;

2668;124,67924204475885;30,274634125205218;10,0;;130;77,49987954168276;72,12991752071154;10,0;;;;;

2669;119,5608584973066;30,002410638384724;10,0;;131;76,24988814584827;71,72991752071155;10,0;;;;;

2670;114,44968564118759;30,38694646308941;10,0;;132;74,99989675001379;71,32991752071155;10,0;;;;;

2671;109,4296487933935;31,421927531709088;10,0;;;;;;;;;;

2672;104,5831768201783;33,09035948370802;10,0;;;;;;;;;;

2673;99,98984865735568;35,36484671256323;10,0;;;;;;;;;;

2674;95,72508662636812;38,208042200858316;10,0;;;;;;;;;;

Anhang B: Simulationsdaten 89

B2: Beispiel einer Schneidkontur im CSV-Format

0;8

1,25;7,6

2,5;7,2

3,75;6,8

5;6,4

6,25;6

7,5;5,6

8,4;5,1

9;4,85

9;3,15

8,4;2,9

7,5;2,4

6,25;2

5;1,6

3,75;1,2

2,5;0,8

1,25;0,4

0;0

Glossar 90

Glossar

Eclipse:

Eclipse wurde ursprünglich als integrierte Entwicklungsumgebung für

Java entwickelt, ist heute aber eine quelloffene Entwicklungsumge-

bung für Programmiersprachen unterschiedlicher Art.

Evolvente:

Eine Evolvente ist eine spezielle mathematische Kurvenform. Sie

wird umgangssprachlich auch als Fadenlinie bezeichnet. Am besten

vorstellen kann man sich eine Evolvente anhand eines Fadens, wel-

cher um einen Kreis gewickelt ist. Am Ende des Fadens befestigt

man nun einen Stift. Wickelt man nun den Faden im straff gespann-

ten Zustand ab, so zeichnet der Stift eine Evolvente. In der folgen-

den Abbildung beschreibt die orangefarbene Kurve eine Evolvente.

Abbildung 28: Evolvente

Glossar 91

FEM:

FEM steht für „Finite-Elemente-Methode“ und ist die Bezeichnung für ein

numerisches Verfahren zur Lösung von Gleichungssystemen bei Fest-

körpersimulationen. Bei dieser Methode wird der Festkörper räumlich

diskretisiert und mit physikalischen Metarialeigenschaften versehen. An-

hand der durchgeführten Simulationen, lassen sich Verformungen sowie

mechanische und thermische Belastungen berechnen (vgl. [FEM 2011]

und [Klein 2010], S. 1).

Oktant:

Ein dreidimensionales kartesisches Koordinatensystem ist in acht Ok-

tanten aufgeteilt. Die Oktanten werden dabei durchnummeriert, begin-

nend mit dem Oktanten I, bei dem alle drei Koordinaten positiv sind.

Polygonzug:

Ein Polygonzug besteht aus mehreren Punkten, welche durch Kanten

verbunden sind. Aus diesem Grund wird dafür auch manchmal die Be-

zeichnung Linienzug oder Streckenzug verwendet.

Schlichten:

Beschreibt in der spanenden Fertigung das Abtragen von Werkstoff mit

einem kleinen Spanvolumen.

Schruppen:

Beschreibt in der spanenden Fertigung das Abtragen von Werkstoff mit

einem großen Spanvolumen.

Shifting:

Um einen Wälzfräser gleichmäßig abzunutzen, kann der Fräser zwi-

schen zwei Fräsprozessen in tangentialer Richtung verschoben werden.

Damit wird ein gleichmäßiger Verschleiß der Schneidzähne erreicht.

Swing:

Eine Java-Bibliothek zum entwickeln von grafischen Benutzungsoberflä-

chen (vgl. [Darwin 2002], S. 383 ff.).

SWT:

Eine Grafikbibliothek für Java, welche in Konkurrenz zu der Java-

eigenen Swing Bibliothek entwickelt wurde. IBM hat SWT für die Ver-

wendung in der Entwicklungsumgebung Eclipse entwickelt.

Virtuelle Schneidkontur:

Begriff, den Gerd Sulzer in seiner Dissertation [Sulzer 1973] für die in

den Schnittebenen beschriebene Schneidkontur des Werkzeugs ge-

wählt hat.

Glossar 92

Virtuelles Universum:

Standardbezeichnung (auch Virtual Universe) in Java3D. Es beschreibt

den durch das dreidimensionale Koordinatensystem aufgespannten

Raum.

Werkradfestes Koordinatensystem:

Bei einem werkradfesten Koordinatensystem rotiert das Koordinatensys-

tem mit dem Werkrad. Gerd Sulzer verwendet dies in seiner Dissertation

[Sulzer 1973], um die Schneiden zu einem gegebenen Zeitpunkt in die-

sem Koordinatensystem zu beschreiben. Dabei wird immer nur eine

Zahnlücke beschrieben. Die Betrachtung der Durchdringung findet somit

aus der Sicht der jeweiligen Zahnlücke statt.

WYSIWYG:

Englische Abkürzung für: „What you see is what you get“. Wird häufig

bei Software verwendet, mit der sich Benutzungsoberflächen gestalten

lassen und dabei in der Entwicklungsumgebung so aussehen wie im fi-

nalen Produkt.

Literaturverzeichnis 93

Literaturverzeichnis

[Agoston 2005a] Agoston, M.A.: Computer Graphics an Geometric Modeling – Implementation and Algorithms. Springer, London 2005

[Agoston 2005b] Agoston, M.A.: Computer Graphics an Geometric Modeling – Mathematics. Springer, London 2005

[Albers 2006] Albers, A ; u.a.: Konstruktionselemente des Maschinenbaus 2. 5. Auflage, Sprin-ger, Berlin 2006

[Bouzakis 2002] Bouzakis, K. D. ; Kombogiannis, S. ; Antoniadis, A. ; Vidakis, N. Gear hobbing cutting process simulation and tool wear prediction models. Journal of Manufacturing Science and Engineering 124 (2002) No. 1, pp. 42-51

[Bouzakis 2008] Bouzakis, K.-D.; Lili, E.; Michailidis, N.; Friderikos, O.: Manufacturing of cylindrical gears by generating cutting processes: A critical synthesis of analysis methods. CIRP Annals - Manufacturing Technology 57 (2008) No. 2, pp. 676-696

[Bronstein 1993] Bronstein, I.N. ; Semendjajew, G. ; Musiol, G. ; Mühlig, H.: Taschenbuch der Mathematik. Harri Deutsch, Frankfurt am Main 1993

[Claudin 2009] Claudin, C ; Rech, J.: Development of a new rapid characterization method of hob’s wear resistance in gear manufacturing. Journal of Materials Processing Technology 209 (2009) No. 11, pp. 5152-5160

[Darwin 2002]

Darwin,I.F.: Java Kochbuch. O’Reilly, Köln 2002

[Dimitrou 2009] Dimitrou, V. ; Antoniadis, A.: CAD-based simulation of the hobbing process for the manufac-turing of spur and helical gears. The International Journal of Ad-vanced Manufacturing Technology 41 (2009) No. 3-4, pp. 347-357

[Gacka 2006] Gacka, A. ; Klein, A. ; Schlattmeier, H. ; Weck, M.: 100 Jahre Produktionstechnik. Springer, Berlin 2006


[Grote 2007] Grote, K.-H. ; Feldhusen, J. Dubbel – Taschenbuch für den Maschinenbau. 22. Auflage, Springer, Berlin 2007

[Hou 2003] Hou, Z.: Beitrag zur voxelbasierten Simulation des fünfachsigen NC-Fräsens. Diss. Technische Universität Berlin, Berlin 2003

[Klawonn 2009] Klawonn, F.: Grundkurs Computergrafik mit Java. Vieweg + Teubner, Wiesbaden 2009

[Klein 2010] Klein, B.: Grundlagen und Anwendungen der Finite-Element-Methode im Maschinen- und Fahrzeugbau. 8. Auflage, Vieweg+Teubner, Wiesbaden 2010

[Klocke 2008] Klocke, F.: Fertigungsverfahren 1. Drehen, Fräsen, Bohren. 8. Auflage, Springer, Berlin 2008

[Niemann 2003] Niemann, G. ; Winter, H.: Maschinenelemente: Getriebe allgemein, Zahnradgetriebe, Grundlagen, Stirnradgetriebe. Bd. 2, Springer, Berlin 2003

[Obermeier 2007] Obermeier: Verzahnwerkzeug für die Vorverzahnung. (Unveröffentlichtes Manuskript Verzahnungsseminar) Ludwigsburg 2007

[Sulzer 1973] Sulzer, G.: Leistungssteigerung bei der Zylinderradherstellung durch syste-matische Erfassung der Zerspantechnik. Diss. RWTH Aachen, Aachen 1973

[Vasilis 2007] Vasilis, D. ; Nectarios, V. ; Aristomenis, A.: Advanced Computer Aided Design Simulation of Gear Hobbing by Means of Three-Dimensional Kinematics Modeling. Journal of Manufacturing Science and Engineering 129 (2007) No. 5, pp. 911-918

[Weigel] Weigel, U.: Prozesskette der Zahnradfertigung. (Unveröffentlichtes Vorle-sungsmanuskript)

[Weiler 1977] Weiler, K. ; Atherton, P.: Hidden Surface Removal Using Polygon Area Sorting. ACM SIGGRAPH Computer Graphics 11 (1977) No. 2, pp. 214-222


Online Quellen:

[Aenderl 2009] (Ver)rechnen mit Java – Double vs. BigDecimal http://www.pro4j.de/verrechnen-mit-java-double-vs-bigdecimal zuletzt besucht: 02.02.2011

[Brep 2010] Boundary Representation http://de.wikipedia.org/w/index.php?title=Boundary_Representation&oldid=77855989 zuletzt besucht: 09.02.2011

[Extrusion 2011] Extrusion (Geometrie) http://de.wikipedia.org/w/index.php?title=Extrusion_(Geometrie)&oldid=78479847 zuletzt besucht: 11.02.2011

[FEM 2011] Finite-Elemente-Methode http://de.wikipedia.org/w/index.php?title=Finite-Elemente-Methode&oldid=84804924 zuletzt besucht: 12.02.2011

[Gauß 2011] Gaußsche Trapezformel http://de.wikipedia.org/w/index.php?title=Gau%C3%9Fsche_Trapezformel&oldid=74904228 zuletzt besucht: 18.01.2011

[Hobicam 2010] LOGICIEL DE SIMULATION DE TAILLAGE D’ENGRENAGE (Produktbroschüre) http://mhac-technologies.com/www/brochures/hobicam.pdf zuletzt besucht: 16.12.2010

[IWV 2010] Die Entwicklung der Zahnradfertigung http://www.institut-wv.de/3540.html zuletzt besucht: 12.12.2010

[IEEE754] IEEE Standard for Binary Floating-Point Arithmetic http://754r.ucbtest.org/standards/754.pdf zuletzt besucht: 02.02.2011

[Java3D 2011] Java3D http://de.wikipedia.org/w/index.php?title=Java_3D&oldid=78208570 zuletzt besucht: 21.01.2011


[JFormDesigner] JFormDesigner – Java / Swing GUI Designer http://www.formdev.com/jformdesigner/ zuletzt besucht: 21.01.2011

[CDC6000 2011] CDC 6000 Series http://en.wikipedia.org/w/index.php?title=CDC_6000_series&oldid=404382121 zuletzt besucht: 04.02.2011

[SpartaPro 2010] SPARTApro - Ein Simulationsprogramm zur Analyse von Wälzfräsprozessen http://www.wzl.rwth-aachen.de/cms/www_content/de/4be43aa81036c58ac125707c004d981f.htm zuletzt besucht: 12.12.2010

Erklärung 97

Erklärung

Hiermit erkläre ich, dass ich die vorliegende Diplomarbeit selbständig angefertigt habe.

Es wurden nur die in der Arbeit ausdrücklich benannten Quellen und Hilfsmittel be-

nutzt. Wörtlich oder sinngemäß übernommenes Gedankengut habe ich als solches

kenntlich gemacht.

Ort, Datum Unterschrift

Modellierung und Simulation von Zerspanverfahren mithilfe...

Documents

Transcript of Modellierung und Simulation von Zerspanverfahren mithilfe...