Skip to main content

FVA Workbench KnowledgeBase

Beispiele

Variation: Drehwegfehler über Schrägungswinkel

Das folgende Script erhöht in jedem Durchlauf den Schrägungswinkel eines Stirnrades um 1°, führt eine Gesamtsystemberechnung inklusive Verzahnungsanregung durch und gibt den maximalen Drehwegfehler auf dem Scripting-Monitor aus.

Download (Modell inkl. Script)

Download (Nur Script)

scripting_editor.png

Ausführung des Scripts in der FVA-Workbench

1var gearUnitID = 1;
2var stageID = getCompByType("cylindrical_mesh")[0];
3var gearID = getCompByType("cylindrical_gear")[0];

4setAttr("gta_switch_deactivate_all_calculations", gearUnitID, true, EDAT);
5setAttr("gta_switch_3d_load_distribution_analytical", gearUnitID, true, EDAT);
6setAttr("gta_switch_3d_force_excitation", gearUnitID, true, EDAT);

7for(angle = 0; angle <= 20; angle++){
8    setAttr("helix angle reference diameter", gearID, angle, EDAT);
9    runCalcMethod("001_SYSTEM_CALCULATION", gearUnitID);
10    var trans_error_max = getAttr("result_transmission_error_maximum", stageID, RDAT);
11    println("Transmission Error at "+angle+"°: "+trans_error_max+" µm");
     }

1

Komponenten ID der Getriebeeinheit

2

getCompByType("cylindrical_mesh") liefert eine Liste aller Stirnradstufen im Modell. [0] fragt das erste Element in dieser Liste ab. stageID enthält jetzt die ID der ersten Stirnrstufe im Modell.

3

getCompByType("cylindrical_gear") liefert eine Liste aller Stirnräder im Modell. [0] fragt das erste Element in dieser Liste ab. gearID enthält jetzt die ID des ersten Stirnrades im Modell.

4

Setzt alle Schalter für Gesamtsystem-Zusatzberechnungen auf false.

5

Setzt den Gesamtsystem-Berechnungsschalter für "Lastverteilung (analytisch)" auf der Getriebeeinheit auf true.

6

Setzt den Gesamtsystem-Berechnungsschalter für "Verzahnungsanregung" auf der Getriebeeinheit auf true.

7

for-Schleife, in der die Laufvariable angle bei jedem Durchlauf um 1 erhöht wird. Bei angle = 20 wird die Ausführung beendet.

8

setAttr() setzt den Eingabewert (EDAT) für das Geometrieattribut "helix angle reference diameter" (Schrägungswinkel) auf dem Stirnrad in der Variable gear.

9

runCalcMethod("001_SYSTEM_CALCULATION", gearUnitID); führt in jedem Schleifendurchlauf eine Gesamtsytemberechnung durch.

10

In jedem Durchlauf wird der Ergebniswert aus dem Attribut "Maximale Drehwegabweichung" in die Variable trans_error_max geschrieben.

11

Ausgabe eines zusammengesetzten Strings (Text + Winkel + Maximale Drehwegabweichung) auf dem Scripting-Monitor der FVA-Workbench

Modifikationsmatrix aus Excel einlesen

Das folgende Script liest die Höhen-, Breitenkoordinaten und die Modifikationsmatrix aus einer Exceldatei ein und schreibt diese Werte in die entsprechenden Attribute einer Modifikationskomponente im FVA-Workbench Modell. Dabei werden die Excel-Scriptfunktionen getValuesRow(), getValueColumn() und getValuesMatrix() verwendet um die Arrays und die Matrix aus der Excel-Datei in Script Variablen zu schreiben.getValuesRow()getValuesColumn()getValuesMatrix()

modification_matrix_editor.png
let excelfile = "C:\\folder\\modification_matrix.xlsx";
let workbook = workbookFactory.createWorkbook(excelfile);

let modificationID = 1399;
let width_coords = workbook.getValuesRow("B1", 5);
let height_coords = workbook.getValuesColumn("A2", 6);
let mod_matrix = workbook.getValuesMatrix("B2", 6, 5);

println(width_coords);
println(height_coords);
println(mod_matrix);

setAttr("sekor_matrixk_enabled", modificationID, true, EDAT);
setAttr("width_coordinates", modificationID, width_coords, EDAT);
setAttr("height_coordinates", modificationID, height_coords, EDAT);
setAttr("modification_matrix", modificationID, mod_matrix, EDAT);

Optimierung: Minimaler Breitenlastfaktor

Das folgende Script ermittelt den optimalen Betrag für eine Schrägungswinkelkorrektur, sodass der Breitenlastfaktor KHBeta minimal wird.

Korrekturen sind in der FVA-Workbench eigene Komponenten, die auf einem Stirnrad eingefügt werden können. Auf der Korrekturkomponente können mehrere Korrekturarten (z.B. Breitenballigkeit, Höhenballigkeit) aktiviert und bedatet werden. In diesem Fall soll die Schrägungswinkelkorrektur aktiviert werden. Im Editor der FVA-Workbench gibt es hierfür unter der Korrekturkomponente den Schalter "Schrägungswinkelkorrektur berücksichtigen". Um diesen Schalter via Scripting zu aktivieren, muss das Attribut "sekor_CHB_enabled" auf true gesetzt werden.

Weiterhin wird das Attribut "Form der Schrägungswinkelkorrektur" auf "Am Beginn der Zahnbreite (kleinere u-Koordinate)" gesetzt. Um diese Auswahl via Scripting zu treffen, muss das Attribut "sekor_hcb_form" auf den Wert "3" gesetzt werden.

Für weitere Informationen zum Thema "Setzen von Attributwerten" siehe Datentypen

Dieses Script benötigt für seine Ausführung ein Modell, dass mindestens eine Stirnradstufe enthält, wobei auf mindestens einem der Räder eine Korrekturkomponente eingefügt ist.

Download (Modell inkl. Script)

Download (Nur Script)

Teil 1: Richtung der Korrektur bestimmen

Im ersten Schritt muss die Richtung der Korrektur bestimmt werden. Da als Form der Schrägungswinkelkorrektur "Am Beginn der Zahnbreite" ausgewählt wurde, bezieht sich die Korrekturrichtung auf den Punkt A in der Abbildung. In diesem Fall ist die Korrekturrichtung links, es wird auf der linken Seite Material abgetragen. Ist die Korrekturrichtung rechts, wird auf der rechten Seite (Punkt B) Material abgetragen. Ist die Richtung rechts, wird der Korrekturbetrag positiv angegeben. Dementsprechend wird bei Korrekturrichtung links ein negativer Betrag angegeben.

helix_modification.png

Beispiel für einen Korrekturabtrag links von z.B. +15µm, ausgehend vom Punkt A, dem Beginn der Zahnbreite.

Damit das folgende Script auf beliebige Modelle angewendet werden kann, werden die Komponenten IDs nicht fest in Variablen gespeichert, sondern über die prompt() Funktion vom Scriptbenutzer zur Laufzeit abgefragt.

Die Ermittlung der Korrekturrichtung erfolgt folgendermaßen:

  1. Berechnung von KHBeta ohne Korrektur

  2. Berechnung von KHBeta mit einem Korrekturbetrag von +1µm

  3. Berechnung von KHBeta mit einem Korrekturbetrag von -1µm

  4. Ist der Wert von KHBeta bei +1µm größer als bei -1µm ist die Korrekturrichtung Rechts, ansonsten Links

1var stageID = prompt("Enter Cylindrical Stage ID");
2var gearID = prompt("Enter Cylindrical Gear ID");
3var modificationID = getSubComponents(gearID, "gear_correction")[0];
4var gearUnitID = 1;

5setAttr("sekor_CHB_enabled", modificationID, true, EDAT);
6setAttr("sekor_hcb_form", modificationID, "3", EDAT);

7setAttr("sekor_chb_bet", modificationID, 0, EDAT);
8runCalcMethod("001_SYSTEM_CALCULATION", gearUnitID);
9var khBetaNoMod = getAttr("gta_result_face_load_factor_flank", stageID, RDAT);
10println("KH_Beta unkorrigiert: " + khBetaNoMod);

11setAttr("sekor_chb_bet", modificationID, 1, EDAT);
12runCalcMethod("001_SYSTEM_CALCULATION", gearUnitID);
13var khBetaPosMod = getAttr("gta_result_face_load_factor_flank", stageID, RDAT);

14setAttr("sekor_chb_bet", modificationID, -1, EDAT);
15runCalcMethod("001_SYSTEM_CALCULATION", gearUnitID);
16khBetaNegMod = getAttr("gta_result_face_load_factor_flank", stageID, RDAT);

17if (khBetaPosMod > khBetaNegMod){
18    var direction = "right";
19}else {var direction = "left";} //kleine u-Koordinate

20println("Direction of modification: "+direction);

1

Nutzereingabe der Stufen ID in Variable stageID schreiben.

2

Nutzereingabe der Rad ID in Variable gearID schreiben.

3

Über getSubComponents() werden alle Korrekturkomponenten auf dem Stirnrad abgefragt. Über [0] wird nur die ID der ersten Korrektur in modificationID geschrieben.

4

Variable gearUnitID mit der ID der Getriebeeinheit belegen.

5

Attribut "Schrägungswinkelkorrektur berücksichtigen" auf der Korrekturkomponente auf true setzen.

6

Attribut "Form der Schrägungswinkelkorrektur" auf den Wert "3" setzen.

7

Eingabewert (EDAT) des Attributs "Betrag der Schrägungswinkelkorrektur" auf den Wert 0 (µm) setzen.

8

Gesamtsystemberechnung durchführen.

9

Ergebniswert (RDAT) des Attributs "Berechneter Breitenlastfaktor Flanke" auf der Stirnradstufe in khBetaNoMod schreiben.

10

Den Wert für KHBeta (unkorrigiert) auf der Scripting-Monitor ausgeben.

11

Eingabewert (EDAT) des Attributs "Betrag der Schrägungswinkelkorrektur" auf den Wert 1 (µm) setzen.

12

Gesamtsystemberechnung durchführen.

13

Ergebniswert (RDAT) des Attributs "Berechneter Breitenlastfaktor Flanke" auf der Stirnradstufe in khBetaPosMod schreiben.

14

Eingabewert (EDAT) des Attributs "Betrag der Schrägungswinkelkorrektur" auf den Wert -1 (µm) setzen.

15

Gesamtsystemberechnung durchführen.

16

Ergebniswert (RDAT) des Attributs "Berechneter Breitenlastfaktor Flanke" auf der Stirnradstufe in khBetaNegMod schreiben.

17

Wenn khBetaPosMod kleiner als khBetaNegMod:

18

Dann Variable direction mit dem String "right" belegen.

19

Sonst Variable direction mit dem String "left" belegen.

20

Ausgabe der Korrekturrichtung auf dem Scripting-Monitor.

Teil 2: Iterative Ermittlung des optimalen Korrekturbetrags

Ein Ergebnis der Gesamtsystemberechnung ist der 2D-Korrekturvorschlag für eine gleichmäßige Lastverteilung. Dabei wird der Korrekturbetrag auf mehrere Stützstellen über der Zahnbreite in einem Arrayattribut (correction_proposal_system_calculation) gespeichert. Ziel der Optimierung in diesem Script soll sein, dass die Differenz zwischen dem ersten Punkt im Array (1) und dem letzten (2) kleiner als 1 wird.

Dabei wird folgendermaßen vorgegangen:

  1. Aktuellen Korrekturwert in Variable speichern.

  2. Differenz zwischen erstem und letztem Punkt im Array ermitteln.

  3. Je nach Korrekturrichtung die Differenz zum aktuellen Korrekturbetrag addieren oder subtrahieren.

  4. Gesamtsystemberechnung mit dem neuen Korrekturwert durchführen.

  5. Erneut die Differenz ermitteln -> Ist die Differenz kleiner als 1 wird das Script beendet.

mod_proposal.png

Das Berechnungsergebnis Korrekturvorschlag kann über das Attribut correction_proposal_system_calculation abgefragt werden.

1do {
2   runCalcMethod("001_SYSTEM_CALCULATION", gearUnitID);
3   var helixAngleModAmount = getAttr("sekor_chb_bet", modificationID, RDAT);
4   var correctionProposal = getAttr("correction_proposal_system_calculation", stageID, RDAT);

5   var delta = correctionProposal[0] - correctionProposal[correctionProposal.length-1];
6   if (direction == "left"){
7       var newHelixAngleModAmount = helixAngleModAmount + delta;
8   }else{  newHelixAngleModAmount = helixAngleModAmount - delta;}

9   setAttr("sekor_chb_bet", modificationID, newHelixAngleModAmount, EDAT);
10   println("Modification Amount: "+newHelixAngleModAmount+" mym"+" -> delta: "+ delta);
11}while(delta < 1);

12runCalcMethod("001_SYSTEM_CALCULATION", gearUnitID);
13var finalKhBeta = getAttr("gta_result_face_load_factor_flank", stageID, RDAT);
14println("Final KH_Beta: "+finalKhBeta);

1

Start der do-while Schleife.

2

Gesamtsystemberechnung starten.

3

Ergebniswert (RDAT) des Attributs "Schrägungswinkelkorrekturbetrag" in die Variable helixAngleModAmount schreiben.

4

Ergebniswert des Arrayattributs "Korrekturvorschlag aus Gesamtsystemberechnung" in die Variable correctionProposal schreiben.

5

Den letzten Wert im Array correctionProposal vom ersten Wert abziehen und in die Variable delta schreiben

6

Wenn Korrekturrichtung Links:

7

Differenzbetrag zur Variable helixAngleModAmount addieren und Wert in newHelixAngleModAmount schreiben.

8

Sonst: Differenzbetrag von der Variable helixAngleModAmount abziehen und Wert in newHelixAngleModAmount schreiben.

9

Eingabewert (EDAT) des Attributs "Betrag der Schrägungswinkelkorrektur" auf newHelixAngleModAmount setzen.

10

Neuen Korrekturbetrag + Differenz auf dem Scripting-Monitor ausgeben.

11

do-while Schleife solange wiederholen bis die Differenz kleiner als 1 ist.

12

Nach Beendigung der Schleife -> Gesamtsystemberechnung mit dem finalen Korrekturbetrag durchführen.

13

Den finalen KHBeta Wert auf dem Scripting-Monitor ausgeben.

Formatierte Textausgabe in Datei schreiben

Das folgende Script erzeugt eine Textdatei, in der Name, Formelzeichen, Wert und Einheit mehrerer Attribute formatiert dargestellt werden. Für die Formatierung wird die format() Funktion verwendet. Die Ausgabe in eine Datei erfolgt über die Funktion writeToFile().

text_file.png

Ausgabedatei des Scripts

Download (Modell inkl. Script)

Download (Nur Script)

Teil 1: formatAttr() Funktion

In diesem Script wird eine Funktion formatAttr() mit den Parametern attributeID compID und dat deklariert. Die Funktion wird dann für jedes Attribut, dass in der Ausgabedatei erscheinen soll, aufgerufen. Der Rückgabewert der Funktion ist ein String "Attributname Formelzeichen Wert Einheit".

1function formatAttr(attributeID, compID, DAT) { 
2   let name = getAttrProperty(attributeID, compID , 'NAME');
3   let symbol = getAttrProperty(attributeID, compID , 'SYMBOL');
4   let value = getAttr(attributeID, compID, DAT)+0.0;
5   let unit = getAttrProperty(attributeID, compID , 'UNIT_NAME'); 
    
6   let format_name   = format("%-35s", name);
7   let format_symbol = format("%-10s",  symbol);
8   let format_value;
9   let valueType = typeof value;
  
10  if(valueType == "number" && value %1 == 0){
11	 valueType = "int";
       }
12  switch (valueType) {
13     case "number": format_value = format("%-12.3f", value); break;
14     case "int":    format_value = format("%-12.0f", value); break; 
15     case "string": format_value = format("%-12s", value); break;
16     default:       format_value = format("%-12s", "Error"); break;
       }
17  let format_unit = format("%-3s", unit);
18  let resultstring = format_name + format_symbol + format_value + format_unit +"\n";
19  return resultstring;
}

1

Deklariert die Funktion formatAttr() mit den Parametern AttributID, KomponentenID und DAT (siehe Datenhaltung (EDAT/RDAT)).

2

Fragt den Namen des Attributs ab und schreibt ihn in die Variable name.

3

Fragt das Formelzeichen des Attributs ab und schreibt es in die Variable symbol.

4

Fragt den Eingabewert (EDAT) oder den Ergebniswert (RDAT) des Attributs ab und schreibt es in die Variable value (+0.0 wird aus Kompatibilitätsgründen verwendet).

5

Fragt die Einheit des Attributs ab und schreibt sie in die Variable unit.

6

Formatiert den Inhalt von name (Linksbündig, 35 Felder breit) und schreibt das Ergebnis in die Variable format_name.

7

Formatiert den Inhalt von symbol (Linksbündig, 10 Felder breit) und schreibt das Ergebnis in die Variable format_symbol.

8

Deklariert eine neue Variable format_value.

9

typeof liefert den Datentyp ("string" oder "number") zurück.

10

Fallunterscheidung: Wenn value vom Datentyp "number" ist und die Division mit Rest = 0 ergibt:

11

dann wird die Variable valueType auf "int" gesetzt

12

switch-Anweisung in der die Variable valueType ausgewertet wird.

13

Wenn valueType = "number", dann wird value linksbündig mit Feldbreite 12 und 3 Nachkommastellen formatiert.

14

Wenn valueType = "int", dann wird value linksbündig mit Feldbreite 12 und 0 Nachkommastellen formatiert.

15

Wenn valueType = "string", dann wird value linksbündig mit Feldbreite 12 formatiert.

16

Für jeden anderen Fall wird "Error" ausgegeben (bspw. wenn das abgefragte Attribut vom Datentyp "array" ist).

17

Formatiert den Inhalt von unit (Linksbündig, 3 Felder breit) und schreibt das Ergebnis in die Variable format_unit.

18

Fügt alle format_ Variablen zu einem String zusammen, fügt am Ende eine Zeilenumbruch hinzu und schreibt alles in die Variable resultstring.

19

resultstring wird als Ergebnis der Funktion an den Aufrufer zurückgeliefert.

Teil 2: Ausgabedatei schreiben

Um die Ausgabedatei zu schreiben, wird für jedes Attribut die oben deklarierte Funktion formatAttr() aufgerufen. Der Rückgabewert der Funktion wird dann per writeToFile() in die angegebene Datei geschrieben.

1let filepath = "C:\\geometry.txt";
2let stageID = 3;
3let gearID = 8;

4writeToFile(filepath, "---------------------- Geometry ---------------------------\n", "c", "UTF-8");
5writeToFile(filepath, formatAttr("normal module", gearID, EDAT), "a", "UTF-8");
6writeToFile(filepath, formatAttr("face width", gearID), "a", "UTF-8", EDAT);
7writeToFile(filepath, formatAttr("center_distance_editor", stageID, RDAT), "a", "UTF-8");
8writeToFile(filepath, formatAttr("helix angle reference diameter", gearID, EDAT), "a", "UTF-8");
9writeToFile(filepath, formatAttr("addendum modification coefficient", gearID, EDAT), "a", "UTF-8");
10writeToFile(filepath, formatAttr("minimum_tip_clearance_factor", gearID, EDAT), "a", "UTF-8");

1

Pfad und Dateiname der Ausgabedatei

2

ID einer Stirnradstufe

3

ID eines Stirnrads

4

Schreibt eine Überschrift in die Ausgabedatei. "c" erzeugt eine neue Datei, "UTF-8" gibt die Codierung an.

5

Ruft formatAttr() für das Attribut Normalmodul (Eingabewert -> EDAT) auf der Komponente Stirnrad auf. Der Rückgabewert wird in die Datei geschrieben. "a" fügt den String an die bestehende Datei an.

6

Schreibt den String für das Attribut Zahnbreite in die Datei.

7

Schreibt den String für das Attribut Achsabstand in die Datei.

8

Schreibt den String für das Attribut Schrägungswinkel in die Datei.

9

Schreibt den String für das Attribut Profilverschiebungsfaktor in die Datei.

10

Schreibt den String für das Attribut Minimaler Kopfspielfaktor in die Datei.

Ergebnisse in Planetenstufen abfragen

Das folgende Script fragt die maximale Zahnfußspannung für jeden individuelle Zahneingriff in einer Planetenstufe ab und gibt die Ergebnisse in einer Baumstruktur auf dem Scripting-Monitor aus.

planet_instances_stage_gear_data.png
planet_instances_stage_gear_data_monitor.png

Im Modellbaum der FVA-Workbench werden für das oben gezeigte Planetengetriebe nur 2 Stirnradstufen angezeigt, der Eingriff Planet-Hohlrad und der Eingriff Planet-Sonne. Diese 2 Mutterstufen enthalten alle Eingabedaten, die Anzeige aller 6 Verzahnungseingriffe ist nicht nötig. Die Berechnungsergebnisse hingegeben können sich für die individuellen Verzahnungseingriffe (1-6 in der Abbildung) unterscheiden. Daher hat jede der 2 Mutterstufen 3 Instanzkomponenten für die individuellen Stufen. Der Zugriff auf Ergebnisattribute diese Instanzkomponenten wird im folgenden Script gezeigt.

planet_instance_tree.png
planet_instances_stage_gear_data_monitor.png

Ausgabe des Scriptes auf dem Scripting-Monitor.

let planetaryStageID = 9;
let stageIDs = getSubComponents(planetaryStageID, "general_stage");

for (let i = 0; i < stageIDs.length; i++){
    let stageInstanceIDs = getSubComponents(stageIDs[i], "planet_instance");
    let gearsInStageIDs =  getSubComponents(stageIDs[i], "general_gear");
	println(getCompProperty(stageIDs[i], "NAME"));
	
	for (let i = 0; i < stageInstanceIDs.length; i++){
		let planetAngle = getAttr("polar_angle_of_planet_instance", stageInstanceIDs[i], EDAT);
		println("\tIndividual tooth engagement ["+stageInstanceIDs[i]+"] @ "+planetAngle+"°");
		let stageGearDataID1 = getStageGearData(stageInstanceIDs[i], gearsInStageIDs[0]);
		let stageGearDataID2 = getStageGearData(stageInstanceIDs[i], gearsInStageIDs[1]);
		let toothRootStressGear1 = getAttr("result_tooth_root_stress_compression_maximum", stageGearDataID1, RDAT);
		let toothRootStressGear2 = getAttr("result_tooth_root_stress_compression_maximum", stageGearDataID2, RDAT);
	
		println("\t\tTooth root stress maximum "+getCompProperty(gearsInStageIDs[0], "NAME")+": "
		+toothRootStressGear1);
		println("\t\tTooth root stress maximum "+getCompProperty(gearsInStageIDs[1], "NAME")+": "
		+toothRootStressGear2);
	}
}