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
Inhaltsverzeichnis 3
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
Inhaltsverzeichnis 4
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.
Grundlagen und Stand der Technik 11
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
Grundlagen und Stand der Technik 12
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)
Grundlagen und Stand der Technik 13
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).
Grundlagen und Stand der Technik 14
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-
Grundlagen und Stand der Technik 15
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
Grundlagen und Stand der Technik 16
(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.
Grundlagen und Stand der Technik 17
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)
Grundlagen und Stand der Technik 18
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
Grundlagen und Stand der Technik 19
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)
Grundlagen und Stand der Technik 20
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)
Grundlagen und Stand der Technik 21
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-
Grundlagen und Stand der Technik 22
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:
Durchdringungsrechnung
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
Durchdringungsrechnung
Ermittlung von Spanungsquerschnitten sowie der Spanungsgeometrien
Bestimmung dynamischer Eingriffsverhältnisse zwischen Wälzfräser und Werk-
stück
Unterstützung von Ein- und Mehrschnittstrategien
Grundlagen und Stand der Technik 23
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
Grundlagen und Stand der Technik 24
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
Durchdringungsrechnung
Visualisierung der Ergebnisse
Bestimmt die Spanungsgeometrien anhand von Volumensubtraktion
Grundlagen und Stand der Technik 25
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
Durchdringungsrechnung
Visualisierung der Ergebnisse
Bestimmt die Spanungsgeometrien
Grundlagen und Stand der Technik 26
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
Grundlagen und Stand der Technik 27
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).
Grundlagen und Stand der Technik 28
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-
Grundlagen und Stand der Technik 29
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
Grundlagen und Stand der Technik 30
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
System 2 -> System 3
Drehbewegung W23 des Werkrades
Grundlagen und Stand der Technik 31
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
System 3 -> System 4
Radialvorschub C34 des Fräsers
Keine Drehung , Verschiebung C34 in Y-Richtung
T34 = 1
C34 = 0
0
System 4 -> System 5
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
System 5 -> System 6
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
Grundlagen und Stand der Technik 32
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
Grundlagen und Stand der Technik 33
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.
Grundlagen und Stand der Technik 34
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.
Grundlagen und Stand der Technik 35
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
Grundlagen und Stand der Technik 36
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.
Zielsetzung und Vorgehensweise 38
Abbildung 15: Ablaufdiagramm der Durchdringungsrechnung (Schlagzahnfräsen)
Zielsetzung und Vorgehensweise 39
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
Grafikkarte: Eine 3D-fähige Grafikkarte mit Direct3D- oder Open-GL-
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
Grafikkarte: Eine 3D-fähige Grafikkarte mit Direct3D- oder Open-GL-
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
Parametername Beschreibung
Initialposition Y Spindel (mm) Y-Abstand vom Mittelpunkt der Werk-
zeugspindel, bezogen auf dessen Defini-
tion im Ursprung9, in Millimeter.
Initialposition Z Spindel (mm) Z-Abstand vom Mittelpunkt der Werk-
zeugspindel, bezogen auf dessen Defini-
tion im Ursprung9, in Millimeter.
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
dessen Definition im Ursprung10, in Milli-
meter.
Initialposition Z Werkstück (mm) Z-Abstand des Werkstücks, bezogen auf
dessen Definition im Ursprung10, in Milli-
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
Parametername Beschreibung
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.
Ergebnisse und Bewertung 73
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.
Ergebnisse und Bewertung 74
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-
Ergebnisse und Bewertung 75
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.
Ergebnisse und Bewertung 76
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.
Ergebnisse und Bewertung 77
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.
Ergebnisse und Bewertung 78
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
Ergebnisse und Bewertung 79
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
Ergebnisse und Bewertung 80
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
Ergebnisse und Bewertung 81
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.
Ergebnisse und Bewertung 82
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.
Ergebnisse und Bewertung 83
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.
Ergebnisse und Bewertung 84
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
Literaturverzeichnis 94
[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
Literaturverzeichnis 95
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
Literaturverzeichnis 96
[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