Kraftübertragung beim Planetengetriebe

Planetengetriebe 1

OpenSCAD Programm

Planetengetriebe 1

/*
*******************************************
Objekt Info: Planetengetriebe 1

*******************************************
Version: 19.09.2022 khf
*******************************************
*/

//***************   Auswahl   *************

// keine

//*****************************************

//***************   Libraries  ************

// keine

//*****************************************

//***************  Parameter   *************
/*  Parameter fuer die Planetenraeder

Enthaelt die Module
stirnrad(modul, zahnzahl, breite, bohrung, eingriffswinkel = 20, schraegungswinkel = 0, optimiert = 1)

pfeilrad(modul, zahnzahl, breite, bohrung, eingriffswinkel = 20, schraegungswinkel = 0, optimiert = 1)

hohlrad(modul, zahnzahl, breite, randbreite, eingriffswinkel = 20, schraegungswinkel = 0)

pfeilhohlrad(modul, zahnzahl, breite, randbreite, eingriffswinkel = 20, schraegungswinkel = 0)

planetengetriebe(modul, zahnzahl_sonne, zahnzahl_planet, anzahl_planeten, breite, randbreite, bohrung, eingriffswinkel=20, schraegungswinkel=0, zusammen_gebaut=1, optimiert=1)


Module nach DIN 780:
0.05 0.06 0.08 0.10 0.12 0.16
0.20 0.25 0.3  0.4  0.5  0.6
0.7  0.8  0.9  1    1.25 1.5
2    2.5  3    4    5    6
8    10   12   16   20   25
32   40   50   60
*/
// Zusammen gebaut oder zum Drucken getrennt
zusammen_gebaut = 1; // [0,1]

// Hoehe des Zahnkopfes ueber dem Teilkreis
modul=1;
// Anzahl der Radzaehne des Sonnenrads
zahnzahl_sonne=20;
// Anzahl der Radzaehne der Planetenraeder
zahnzahl_planet=10;
// Anzahl Planeten
anzahl_planeten = 5;
// Zahnbreite
breite=10;
// Breite des Randes ab Fusskreis
randbreite=7;
// Durchmesser der Mittelbohrung
bohrung = 4;
// Eingriffswinkel, Standardwert = 20 grad gemaess DIN 867
eingriffswinkel=20;
// Schraegungswinkel zur Rotationsachse; 0 grad = Geradverzahnung
schraegungswinkel=30;
// Loecher zur Material-/Gewichtsersparnis bzw. Oberflaechenvergoesserung erzeugen, wenn Geometrie erlaubt
optimiert = 1; // [0,1]
// Spiel zwischen Zahnflanken
spiel = 0.1;

//*****************************************

//**************   Programm  **************

pi = 3.14159;
rad = 57.29578;
$fn = 300;

/*        Wandelt Radian in Grad um */
function grad(eingriffswinkel) =  eingriffswinkel*rad;


/*        Wandelt Grad in Radian um */
function radian(eingriffswinkel) = eingriffswinkel/rad;


/*        Wandelt 2D-Polarkoordinaten in kartesische um
    Format: radius, phi; phi = Winkel zur x-Achse auf xy-Ebene */
function pol_zu_kart(polvect) = [
        polvect[0]*cos(polvect[1]),
        polvect[0]*sin(polvect[1])
];

/*  Wandelt Kugelkoordinaten in kartesische um
    Format: radius, theta, phi; theta = Winkel zu z-Achse, phi = Winkel zur x-Achse auf xy-Ebene */
function kugel_zu_kart(vect) = [
        vect[0]*sin(vect[1])*cos(vect[2]),
        vect[0]*sin(vect[1])*sin(vect[2]),
        vect[0]*cos(vect[1])
];

/*        Kreisevolventen-Funktion:
    Gibt die Polarkoordinaten einer Kreisevolvente aus
    r = Radius des Grundkreises
    rho = Abrollwinkel in Grad */
function ev(r,rho) = [
        r/cos(rho),
        grad(tan(rho)-radian(rho))
];


/*        prueft, ob eine Zahl gerade ist
        = 1, wenn ja
        = 0, wenn die Zahl nicht gerade ist */
function istgerade(zahl) =
        (zahl == floor(zahl/2)*2) ? 1 : 0;


/*        groesster gemeinsamer Teiler
        nach Euklidischem Algorithmus.
        Sortierung: a muss groesser als b sein */
function ggt(a,b) =
        a%b == 0 ? b : ggt(b,a%b);

/*  Stirnrad
    modul = Hoehe des Zahnkopfes ueber dem Teilkreis
    zahnzahl = Anzahl der Radzaehne
    breite = Zahnbreite
    bohrung = Durchmesser der Mittelbohrung
    eingriffswinkel = Eingriffswinkel, Standardwert = 20 grad gemaess DIN 867. Sollte nicht groesser als 45 grad sein.
    schraegungswinkel = Schraegungswinkel zur Rotationsachse; 0 grad = Geradverzahnung
        optimiert = Loecher zur Material-/Gewichtsersparnis bzw. Oberflaechenvergoesserung erzeugen, wenn Geometrie erlaubt (= 1, wenn wahr) */
module stirnrad(modul, zahnzahl, breite, bohrung, eingriffswinkel = 20, schraegungswinkel = 0, optimiert = 1) {

        // Dimensions-Berechnungen
        d = modul * zahnzahl;                                                                                        // Teilkreisdurchmesser
        r = d / 2;                                                                                                                // Teilkreisradius
        alpha_stirn = atan(tan(eingriffswinkel)/cos(schraegungswinkel));// Schraegungswinkel im Stirnschnitt
        db = d * cos(alpha_stirn);                                                                                // Grundkreisdurchmesser
        rb = db / 2;                                                                                                        // Grundkreisradius
        da = (modul <1)? d + modul * 2.2 : d + modul * 2;                                // Kopfkreisdurchmesser nach DIN 58400 bzw. DIN 867
        ra = da / 2;                                                                                                        // Kopfkreisradius
        c =  (zahnzahl <3)? 0 : modul/6;                                                                // Kopfspiel
        df = d - 2 * (modul + c);                                                                                // Fusskreisdurchmesser
        rf = df / 2;                                                                                                        // Fusskreisradius
        rho_ra = acos(rb/ra);                                                                                        // maximaler Abrollwinkel;
                                                                                                                                        // Evolvente beginnt auf Grundkreis und endet an Kopfkreis
        rho_r = acos(rb/r);                                                                                                // Abrollwinkel am Teilkreis;
                                                                                                                                        // Evolvente beginnt auf Grundkreis und endet an Kopfkreis
        phi_r = grad(tan(rho_r)-radian(rho_r));                                                        // Winkel zum Punkt der Evolvente auf Teilkreis
        gamma = rad*breite/(r*tan(90-schraegungswinkel));                                // Torsionswinkel fuer Extrusion
        schritt = rho_ra/16;                                                                                        // Evolvente wird in 16 Stuecke geteilt
    tau = 360/zahnzahl;                                                                                                // Teilungswinkel

        r_loch = (2*rf - bohrung)/8;                                                                        // Radius der Loecher fuer Material-/Gewichtsersparnis
        rm = bohrung/2+2*r_loch;                                                                                // Abstand der Achsen der Loecher von der Hauptachse
        z_loch = floor(2*pi*rm/(3*r_loch));                                                                // Anzahl der Loecher fuer Material-/Gewichtsersparnis

        optimiert = (optimiert && r >= breite*1.5 && d > 2*bohrung);        // ist Optimierung sinnvoll?

        // Zeichnung
        union(){
                rotate([0,0,-phi_r-90*(1-spiel)/zahnzahl]){                                                // Zahn auf x-Achse zentrieren;
                                                                                                                                                // macht Ausrichtung mit anderen Raedern einfacher

                        linear_extrude(height = breite, twist = gamma){
                                difference(){
                                        union(){
                                                zahnbreite = (180*(1-spiel))/zahnzahl+2*phi_r;
                                                circle(rf);                                                                                // Fusskreis
                                                for (rot = [0:tau:360]){
                                                        rotate (rot){                                                                // "Zahnzahl-mal" kopieren und drehen
                                                                polygon(concat(                                                        // Zahn
                                                                        [[0,0]],                                                        // Zahnsegment beginnt und endet im Ursprung
                                                                        [for (rho = [0:schritt:rho_ra])                // von null Grad (Grundkreis)
                                                                                                                                                // bis maximalen Evolventenwinkel (Kopfkreis)
                                                                                pol_zu_kart(ev(rb,rho))],                // Erste Evolventen-Flanke

                                                                        [pol_zu_kart(ev(rb,rho_ra))],                // Punkt der Evolvente auf Kopfkreis

                                                                        [for (rho = [rho_ra:-schritt:0])        // von maximalen Evolventenwinkel (Kopfkreis)
                                                                                                                                                // bis null Grad (Grundkreis)
                                                                                pol_zu_kart([ev(rb,rho)[0], zahnbreite-ev(rb,rho)[1]])]
                                                                                                                                                // Zweite Evolventen-Flanke
                                                                                                                                                // (180*(1-spiel)) statt 180 Grad,
                                                                                                                                                // um Spiel an den Flanken zu erlauben
                                                                        )
                                                                );
                                                        }
                                                }
                                        }
                                        circle(r = rm+r_loch*1.49);                                                        // "Bohrung"
                                }
                        }
                }
                // mit Materialersparnis
                if (optimiert == 1) {
                        linear_extrude(height = breite){
                                difference(){
                                                circle(r = (bohrung+r_loch)/2);
                                                circle(r = bohrung/2);                                                        // Bohrung
                                        }
                                }
                        linear_extrude(height = (breite-r_loch/2 < breite*2/3) ? breite*2/3 : breite-r_loch/2){
                                difference(){
                                        circle(r=rm+r_loch*1.51);
                                        union(){
                                                circle(r=(bohrung+r_loch)/2);
                                                for (i = [0:1:z_loch]){
                                                        translate(kugel_zu_kart([rm,90,i*360/z_loch]))
                                                                circle(r = r_loch);
                                                }
                                        }
                                }
                        }
                }
                // ohne Materialersparnis
                else {
                        linear_extrude(height = breite){
                                difference(){
                                        circle(r = rm+r_loch*1.51);
                                        circle(r = bohrung/2);
                                }
                        }
                }
        }
}

/*  Pfeilrad; verwendet das Modul "stirnrad"
    modul = Hoehe des Zahnkopfes ueber dem Teilkreis
    zahnzahl = Anzahl der Radzaehne
    breite = Zahnbreite
    bohrung = Durchmesser der Mittelbohrung
    eingriffswinkel = Eingriffswinkel, Standardwert = 20 grad gemaess DIN 867. Sollte nicht groesser als 45 grad sein.
    schraegungswinkel = Schraegungswinkel zur Rotationsachse, Standardwert = 0 grad (Geradverzahnung)
        optimiert = Loecher zur Material-/Gewichtsersparnis */
module pfeilrad(modul, zahnzahl, breite, bohrung, eingriffswinkel = 20, schraegungswinkel=0, optimiert=1){
    echo("pfeilrad",optimiert);

        breite = breite/2;
        d = modul * zahnzahl;                                                                                        // Teilkreisdurchmesser
        r = d / 2;                                                                                                                // Teilkreisradius
        c =  (zahnzahl <3)? 0 : modul/6;                                                                // Kopfspiel

        df = d - 2 * (modul + c);                                                                                // Fusskreisdurchmesser
        rf = df / 2;                                                                                                        // Fusskreisradius

        r_loch = (2*rf - bohrung)/8;                                                                        // Radius der Loecher fuer Material-/Gewichtsersparnis
        rm = bohrung/2+2*r_loch;                                                                                // Abstand der Achsen der Loecher von der Hauptachse
        z_loch = floor(2*pi*rm/(3*r_loch));                                                                // Anzahl der Loecher fuer Material-/Gewichtsersparnis

        translate([0,0,breite]){
                union(){
                        stirnrad(modul, zahnzahl, breite, 2*(rm+r_loch*1.49), eingriffswinkel, schraegungswinkel, false);                // untere Haelfte
                        mirror([0,0,1]){
                                stirnrad(modul, zahnzahl, breite, 2*(rm+r_loch*1.49), eingriffswinkel, schraegungswinkel, false);        // obere Haelfte
                        }
                }
        }
        // mit Materialersparnis
        if (optimiert == 1 && r >= breite*3 && d > 2*bohrung) {
                linear_extrude(height = breite*2){
                        difference(){
                                        circle(r = (bohrung+r_loch)/2);
                                        circle(r = bohrung/2);                                                        // Bohrung
                                }
                        }
                linear_extrude(height = (2*breite-r_loch/2 < 1.33*breite) ? 1.33*breite : 2*breite-r_loch/2){ //breite*4/3
                        difference(){
                                circle(r=rm+r_loch*1.51);
                                union(){
                                        circle(r=(bohrung+r_loch)/2);
                                        for (i = [0:1:z_loch]){
                                                translate(kugel_zu_kart([rm,90,i*360/z_loch]))
                                                        circle(r = r_loch);
                                        }
                                }
                        }
                }
        }
        // ohne Materialersparnis
        else {
                linear_extrude(height = breite*2){
                        difference(){
                                circle(r = rm+r_loch*1.51);
                                circle(r = bohrung/2);
                        }
                }
        }
}

/*        Hohlrad
    modul = Hoehe des Zahnkopfes ueber dem Teilkreis
    zahnzahl = Anzahl der Radzaehne
    breite = Zahnbreite
        randbreite = Breite des Randes ab Fusskreis
    bohrung = Durchmesser der Mittelbohrung
    eingriffswinkel = Eingriffswinkel, Standardwert = 20 grad gemaess DIN 867. Sollte nicht groesser als 45 grad sein.
    schraegungswinkel = Schraegungswinkel zur Rotationsachse, Standardwert = 0 grad (Geradverzahnung) */
module hohlrad(modul, zahnzahl, breite, randbreite, eingriffswinkel = 20, schraegungswinkel = 0) {

        // Dimensions-Berechnungen
        ha = (zahnzahl >= 20) ? 0.02 * atan((zahnzahl/15)/pi) : 0.6;        // Verkuerzungsfaktor Zahnkopfhoehe
        d = modul * zahnzahl;                                                                                        // Teilkreisdurchmesser
        r = d / 2;                                                                                                                // Teilkreisradius
        alpha_stirn = atan(tan(eingriffswinkel)/cos(schraegungswinkel));// Schraegungswinkel im Stirnschnitt
        db = d * cos(alpha_stirn);                                                                                // Grundkreisdurchmesser
        rb = db / 2;                                                                                                        // Grundkreisradius
        c = modul / 6;                                                                                                        // Kopfspiel
        da = (modul <1)? d + (modul+c) * 2.2 : d + (modul+c) * 2;                // Kopfkreisdurchmesser
        ra = da / 2;                                                                                                        // Kopfkreisradius
        df = d - 2 * modul * ha;                                                                                // Fusskreisdurchmesser
        rf = df / 2;                                                                                                        // Fusskreisradius
        rho_ra = acos(rb/ra);                                                                                        // maximaler Evolventenwinkel;
                                                                                                                                        // Evolvente beginnt auf Grundkreis und endet an Kopfkreis
        rho_r = acos(rb/r);                                                                                                // Evolventenwinkel am Teilkreis;
                                                                                                                                        // Evolvente beginnt auf Grundkreis und endet an Kopfkreis
        phi_r = grad(tan(rho_r)-radian(rho_r));                                                        // Winkel zum Punkt der Evolvente auf Teilkreis
        gamma = rad*breite/(r*tan(90-schraegungswinkel));                                // Torsionswinkel fuer Extrusion
        schritt = rho_ra/16;                                                                                        // Evolvente wird in 16 Stuecke geteilt
        tau = 360/zahnzahl;                                                                                                // Teilungswinkel

        // Zeichnung
        rotate([0,0,-phi_r-90*(1+spiel)/zahnzahl])                                                // Zahn auf x-Achse zentrieren;
                                                                                                                                        // macht Ausrichtung mit anderen Raedern einfacher
        linear_extrude(height = breite, twist = gamma){
                difference(){
                        circle(r = ra + randbreite);                                                        // Aussenkreis
                        union(){
                                zahnbreite = (180*(1+spiel))/zahnzahl+2*phi_r;
                                circle(rf);                                                                                        // Fusskreis
                                for (rot = [0:tau:360]){
                                        rotate (rot) {                                                                        // "Zahnzahl-mal" kopieren und drehen
                                                polygon( concat(
                                                        [[0,0]],
                                                        [for (rho = [0:schritt:rho_ra])                        // von null Grad (Grundkreis)
                                                                                                                                        // bis maximaler Evolventenwinkel (Kopfkreis)
                                                                pol_zu_kart(ev(rb,rho))],
                                                        [pol_zu_kart(ev(rb,rho_ra))],
                                                        [for (rho = [rho_ra:-schritt:0])                // von maximaler Evolventenwinkel (Kopfkreis)
                                                                                                                                        // bis null Grad (Grundkreis)
                                                                pol_zu_kart([ev(rb,rho)[0], zahnbreite-ev(rb,rho)[1]])]
                                                                                                                                        // (180*(1+spiel)) statt 180,
                                                                                                                                        // um Spiel an den Flanken zu erlauben
                                                        )
                                                );
                                        }
                                }
                        }
                }
        }

        echo("Aussendurchmesser Hohlrad = ", 2*(ra + randbreite));

}

/*  Pfeil-Hohlrad; verwendet das Modul "hohlrad"
    modul = Hoehe des Zahnkopfes ueber dem Teilkegel
    zahnzahl = Anzahl der Radzaehne
    breite = Zahnbreite
    bohrung = Durchmesser der Mittelbohrung
    eingriffswinkel = Eingriffswinkel, Standardwert = 20 grad gemaess DIN 867. Sollte nicht groesser als 45 grad sein.
    schraegungswinkel = Schraegungswinkel zur Rotationsachse, Standardwert = 0 grad (Geradverzahnung) */
module pfeilhohlrad(modul, zahnzahl, breite, randbreite, eingriffswinkel = 20, schraegungswinkel = 0) {

        breite = breite / 2;
        translate([0,0,breite])
                union(){
                hohlrad(modul, zahnzahl, breite, randbreite, eingriffswinkel, schraegungswinkel);                // untere Haelfte
                mirror([0,0,1])
                        hohlrad(modul, zahnzahl, breite, randbreite, eingriffswinkel, schraegungswinkel);        // obere Haelfte
        }
}

/*        Planetengetriebe; verwendet die Module "pfeilrad" und "pfeilhohlrad"
    modul = Hoehe des Zahnkopfes ueber dem Teilkegel
    zahnzahl_sonne = Anzahl der Zaehne des Sonnenrads
    zahnzahl_planet = Anzahl der Zaehne eines Planetenrads
    anzahl_planeten = Anzahl der Planetenraeder. Wenn null, rechnet die Funktion die Mindestanzahl aus.
    breite = Zahnbreite
        randbreite = Breite des Randes ab Fusskreis
    bohrung = Durchmesser der Mittelbohrung
    eingriffswinkel = Eingriffswinkel, Standardwert = 20 grad gemaess DIN 867. Sollte nicht groesser als 45 grad sein.
    schraegungswinkel = Schraegungswinkel zur Rotationsachse, Standardwert = 0 grad (Geradverzahnung)
        zusammen_gebaut =
        optimiert = Loecher zur Material-/Gewichtsersparnis bzw. Oberflaechenvergoesserung erzeugen, wenn Geometrie erlaubt
        zusammen_gebaut = Komponenten zusammengebaut fuer Konstruktion oder auseinander zum 3D-Druck        */
module planetengetriebe(modul, zahnzahl_sonne, zahnzahl_planet, anzahl_planeten, breite, randbreite, bohrung, eingriffswinkel=20, schraegungswinkel=0, zusammen_gebaut=1, optimiert=1){
         // Dimensions-Berechnungen
        d_sonne = modul*zahnzahl_sonne;                                                                                // Teilkreisdurchmesser Sonne
        d_planet = modul*zahnzahl_planet;                                                                        // Teilkreisdurchmesser Planeten
        achsabstand = modul*(zahnzahl_sonne +  zahnzahl_planet) / 2;                // Abstand von Sonnenrad-/Hohlradachse und Planetenachse
        zahnzahl_hohlrad = zahnzahl_sonne + 2*zahnzahl_planet;                                // Anzahl der Zaehne des Hohlrades
    d_hohlrad = modul*zahnzahl_hohlrad;                                                                        // Teilkreisdurchmesser Hohlrad

        drehen = istgerade(zahnzahl_planet);                                                                // Muss das Sonnenrad gedreht werden?

        n_max = floor(180/asin(modul*(zahnzahl_planet)/(modul*(zahnzahl_sonne +  zahnzahl_planet))));
                                                                                                                                                // Anzahl Planetenraeder: hoechstens so viele, wie ohne

        // Zeichnung
        echo("planeteng",optimiert);

        rotate([0,0,180/zahnzahl_sonne*drehen])
                pfeilrad (modul, zahnzahl_sonne, breite, bohrung, eingriffswinkel, -schraegungswinkel, optimiert);                // Sonnenrad
        echo("planeteng",optimiert);

        if (zusammen_gebaut==1){
        if(anzahl_planeten==0){
            list = [ for (n=[2 : 1 : n_max]) if ((((zahnzahl_hohlrad+zahnzahl_sonne)/n)==floor((zahnzahl_hohlrad+zahnzahl_sonne)/n))) n];
            anzahl_planeten = list[0];                                                                                                // Ermittele Anzahl Planetenraeder
            echo("anzahl_planeten", list[0], list[1], list[2]);
            achsabstand = modul*(zahnzahl_sonne + zahnzahl_planet)/2;                // Abstand von Sonnenrad-/Hohlradachse
            for(n=[0:1:anzahl_planeten-1]){
                translate(kugel_zu_kart([achsabstand,90,360/anzahl_planeten*n]))
                                        rotate([0,0,n*360*d_sonne/d_planet])
                                                pfeilrad (modul, zahnzahl_planet, breite, bohrung, eingriffswinkel, schraegungswinkel, optimiert);        // Planetenraeder
            }
       }
       else{
        echo("anzahl planeten=", anzahl_planeten);
            achsabstand = modul*(zahnzahl_sonne + zahnzahl_planet)/2;                // Abstand von Sonnenrad-/Hohlradachse
            for(n=[0:1:anzahl_planeten-1]){
                translate(kugel_zu_kart([achsabstand,90,360/anzahl_planeten*n]))
                rotate([0,0,n*360*d_sonne/(d_planet)])
                    pfeilrad (modul, zahnzahl_planet, breite, bohrung, eingriffswinkel, schraegungswinkel ,optimiert);        // Planetenraeder
            }
                }
        }
        else{
                planetenabstand = zahnzahl_hohlrad*modul/2+randbreite+d_planet;        // Abstand Planeten untereinander
                for(i=[-(anzahl_planeten-1):2:(anzahl_planeten-1)]){
                        translate([planetenabstand, d_planet*i,0])
                                pfeilrad (modul, zahnzahl_planet, breite, bohrung, eingriffswinkel, schraegungswinkel, optimiert);        // Planetenraeder
                }
        }

        pfeilhohlrad (modul, zahnzahl_hohlrad, breite, randbreite, eingriffswinkel, schraegungswinkel); // Hohlrad

}

planetengetriebe(modul, zahnzahl_sonne, zahnzahl_planet, anzahl_planeten, breite, randbreite, bohrung, eingriffswinkel, schraegungswinkel, zusammen_gebaut, optimiert);

RAW code

Planetengetriebe 1 Einzelteile (Druckversion)

Planetengetriebe 2

/*
*******************************************
Objekt Info: Planetengetriebe 2

*******************************************
Version: 19.09.2022 khf
*******************************************
*/

//***************   Auswahl   *************

// keine

//*****************************************

//***************   Libraries  ************

// keine

//*****************************************

//***************  Parameter   *************
// Durchmesser des aeusseren Zylinders
OuterWheelDiameter  = 65;
// Ringgetriebe Durchmesser vom aeusseren Rad aus
RingGearDiameter           = 60;
Thickness           = 18;
// Abstand zwischen den Zahnraedern
Clearance           = 0.4;
Planets             = 5;
PlanetTeethCount    = 8;
SunToothCountEstimate  = 10;
// Druckwinkel der Schraeglage der Evolventenzaehne
PressureAngle       = 45;
// Die # der Zaehne, die jeder Zahnradzahn spiralfoermig kreuzt
TeethToTwistAcross  = 0.9;
// 0=keine Fuellung; Die Groesse der Waben-Loecher
Infill_HoleSize     = 0;
// aendert die Wabenwandstaerke
Infill_Strength                = 10;
// Die aeussere Kantenwandstaerke der Wabe
Infill_BorderSize        = 1;
// Effekte # von Eckpunkten ueber involute Zahnschritte & # von Scheiben pro Zahnradextruder
Precision                        = 11;
// (0=kein Loch; Die HEX-Lochbreite im Sonnenschutzgetriebe)
CenterHEXHoleWidth  = 6.7;
// Schluesselbundhalter auf der Aussenseite
Keychain = "no"; // [yes, no]
// Die Dicke des Schluesselbundlochs
KeychainThickness = 5;

//*****************************************

//**************   Programm  **************

// VORBERECHNUNGEN--------
InFill_HoleStep = (Infill_HoleSize*3.5) + (((Infill_Strength/100)*(Infill_HoleSize*4)));
MaxTeethDepthRatio = 0.5*1;
PiExact = 1*3.141592653589793238462643383279502884197169399375105820974944592307816406286;
PlanetCount = round(Planets);
PlanetToothCount = round(PlanetTeethCount);
PlanetToothCount_Step1 = round(2/PlanetCount*(SunToothCountEstimate+PlanetToothCount));
PlanetToothCount_Step2 = PlanetToothCount_Step1*PlanetCount%2!=0 ? PlanetToothCount_Step1+1 : PlanetToothCount_Step1;
SunToothCount = PlanetToothCount_Step2*PlanetCount/2-PlanetToothCount;
RingToothCount=SunToothCount+2*PlanetToothCount;
pitchD=0.9*RingGearDiameter/(1+min(PiExact/(2*RingToothCount*tan(PressureAngle)),PiExact*MaxTeethDepthRatio/RingToothCount));
Pitch=pitchD*PiExact/RingToothCount;
helix_angle=atan(2*TeethToTwistAcross*Pitch/Thickness);
phi = $t * 360 / PlanetCount;
PlanetOffset = pitchD/2*(SunToothCount+PlanetToothCount)/RingToothCount;
PlanetRotationMultiplier = SunToothCount/PlanetCount*360/PlanetToothCount-phi*(SunToothCount+PlanetToothCount)/PlanetToothCount-phi;


// USER INFO --------------------------------------------------------------
echo("Planets",Planets);

echo("SunToothCount",SunToothCount);
echo("PlanetToothCount",PlanetTeethCount);
echo("RingToothCount", RingToothCount);

echo("PlanetOffset",PlanetOffset);

echo("RingGearDiameter",RingGearDiameter);
echo("Thickness",Thickness);
echo("Clearance",Clearance);

echo("TeethToTwistAcross",TeethToTwistAcross);
echo("helix_angle=",helix_angle);
echo("PressureAngle",PressureAngle);
echo("Pitch",Pitch);

echo("CenterHEXHoleWidth",CenterHEXHoleWidth);


// ----------------------------------------------------------
translate([0,0,Thickness/2]){
    // AUssENRING GETRIEBE
        difference(){
        //cylinder(r=OuterWheelDiameter/2,h=Thickness,center=true,$fn=(Precision*10));

                union()
                        {
                                pitch_radius                 = RingToothCount*Pitch/(2*PiExact);
                                depth                                 = Pitch/(2*tan(PressureAngle));
                                outer_radius                 = Clearance<0 ? pitch_radius+depth/2-Clearance : pitch_radius+depth/2;


                                cylinder(r=outer_radius+Infill_BorderSize+0.5,h=Thickness,center=true,$fn=(Precision*10));
                                Infill_Cylinder(IRadius=OuterWheelDiameter/2,IHeight=Thickness,IPrecision=Precision,
                                                                IHoleSize=Infill_HoleSize, IHoleStep=InFill_HoleStep, IBorderSize=Infill_BorderSize);
                        }

                herringbone(RingToothCount,Pitch,PressureAngle,MaxTeethDepthRatio,-Clearance,helix_angle,Thickness+0.2);
        }
    // SUN GEAR
        rotate([0,0,(PlanetToothCount+1)*180/SunToothCount+phi*(SunToothCount+PlanetToothCount)*2/SunToothCount])
        difference(){
                mirror([0,1,0])
                        herringbone_adv(SunToothCount,Pitch,PressureAngle,MaxTeethDepthRatio,Clearance,helix_angle,Thickness,
                                                        Infill_HoleSize, Infill_Strength, Infill_BorderSize, CenterHEXHoleWidth);
        }

        for(i=[1:PlanetCount])
     rotate([0,0,i*360/PlanetCount+phi])
      translate([PlanetOffset,0,0])
       rotate([0,0,i*PlanetRotationMultiplier])
                herringbone_adv(PlanetToothCount,Pitch,PressureAngle,MaxTeethDepthRatio,Clearance,helix_angle,Thickness,
                                                Infill_HoleSize, Infill_Strength, Infill_BorderSize, 0);


        if( Keychain == "yes")
        {
                echo("DRAWING KEYHOLE");

                translate([(OuterWheelDiameter/2)+(KeychainThickness*1.5), 0, -(Thickness/2)+(KeychainThickness/2)])
                        CreateKeyChainTab(KeychainThickness);
        }
}

module CreateKeyChainTab(KeychainHoleThickness = 5)
{
        difference()
        {
                union()
                {

                        translate([-(KeychainHoleThickness/2),0, 0])
                                cube([KeychainHoleThickness*3,KeychainHoleThickness*2,KeychainHoleThickness], center = true);


                        translate([KeychainHoleThickness,0, 0])
                        rotate([90,0,0])
                                cylinder(d = KeychainHoleThickness, h=(KeychainHoleThickness*2), center = true, $fn=(Precision*10));


                        translate([-(KeychainHoleThickness/2),KeychainHoleThickness, 0])
                        rotate([0,90,0])
                                cylinder(d = KeychainHoleThickness, h=(KeychainHoleThickness*3), center = true, $fn=(Precision*10));


                        translate([-(KeychainHoleThickness/2),-(KeychainHoleThickness), 0])
                        rotate([0,90,0])
                                cylinder(d = KeychainHoleThickness, h=(KeychainHoleThickness*3), center = true, $fn=(Precision*10));


                        translate([(KeychainHoleThickness),(KeychainHoleThickness), 0])
                                sphere(d = KeychainHoleThickness, $fn=(Precision*10));


                        translate([(KeychainHoleThickness),-(KeychainHoleThickness), 0])
                                sphere(d = KeychainHoleThickness, $fn=(Precision*10));
                }

                color("Red")
                translate([0,0, -(KeychainHoleThickness)])
                        cylinder(r = KeychainHoleThickness/1.75, h=(KeychainHoleThickness*2), $fn=(Precision*10));
        }
}

module Infill_Cylinder(IRadius=10,IHeight=10,IPrecision=10, IHoleSize=3.5, IHoleStep=10, IBorderSize=3 )
{
        union()
        {
                difference()
                {
                        cylinder(r=IRadius,h=IHeight,center=true,$fn=(IPrecision*10));

                        Infill_Cylinder_Pattern(IC_Radius=IRadius, IC_Height=IHeight+1, IC_Precision=IPrecision, HoleSize=IHoleSize, HoleStep=IHoleStep);
                }

                difference()
                {

                        cylinder(r=IRadius,h=IHeight,center=true,$fn=(IPrecision*10));

                        cylinder(r=IRadius-IBorderSize,h=IHeight+1,center=true,$fn=(IPrecision*10));
                }
        }
}


module herringbone_adv( number_of_teeth=15, circular_pitch=10, pressure_angle=28, depth_ratio=1, GearClearance=0, helix_angle=0, gear_GearThickness=5,
                                                Infill_HoleSize, Infill_Strength, Infill_BorderSize, CenterHEXHoleWidth)
{
        union()
                {
                        difference()
                        {
                                // herringbone gear
                                herringbone(number_of_teeth,circular_pitch,pressure_angle,depth_ratio,GearClearance,helix_angle,gear_GearThickness);


                                cylinder(r=CenterHEXHoleWidth/sqrt(3),h=gear_GearThickness+1,center=true,$fn=6);

                                 pitch_radius         = number_of_teeth*circular_pitch/(2*PiExact);
                                 base_radius         = pitch_radius*cos(pressure_angle);
                                 depth                         = circular_pitch/(2*tan(pressure_angle));
                                 root_radius1         = pitch_radius-depth/2-GearClearance/2;
                                 root_radius         = (GearClearance<0 && root_radius1<base_radius) ? base_radius : root_radius1;
                                 min_radius         = max (base_radius,root_radius);


                                Infill_Cylinder_Pattern(IC_Radius=  min_radius-Infill_BorderSize, IC_Height=gear_GearThickness+2, IC_Precision=Precision,
                                                                HoleSize=Infill_HoleSize, HoleStep=InFill_HoleStep);
                        }


                        if(CenterHEXHoleWidth > 0)
                        {
                                difference()
                                {

                                        cylinder(r=CenterHEXHoleWidth/sqrt(3)+Infill_BorderSize,h=gear_GearThickness,center=true,$fn=(Precision*10));//6);

                                        cylinder(r=CenterHEXHoleWidth/sqrt(3),h=gear_GearThickness+1,center=true,$fn=6);
                                }
                        }
                }
}

module Infill_Cylinder_Pattern( IC_Radius=10, IC_Height=10, IC_Precision=10, HoleSize=3, HoleStep=3 )
{
    if(HoleSize>0)
        {


        HoneyCombRatio = PiExact/(2*sqrt(3));

        intersection()
        {
                cylinder(r=IC_Radius, h=IC_Height, center=true, $fn=(IC_Precision*10));


                union()
                {
                        StartPosition = (IC_Radius+HoleStep);
                        XStep = (HoleStep*HoneyCombRatio);
                        YStep = (HoleStep*0.5);
                        XOffset = StartPosition - (floor(StartPosition / XStep)*XStep);
                        YOffset = StartPosition - (floor(StartPosition / YStep)*YStep);

                        for(x=[-StartPosition+XOffset:XStep:IC_Radius+HoleStep])
                        {
                                for(y=[-StartPosition+YOffset:YStep:IC_Radius+HoleStep])
                                {
                                        translate([x,y,0])
                                                cylinder(r=HoleSize, h=IC_Height+2, center=true, $fn=6);

                                        translate([x+(HoleStep*(0.5*HoneyCombRatio)),y+(HoleStep*0.75),0])
                                                cylinder(r=HoleSize, h=IC_Height+2, center=true, $fn=6);
                                }
                        }
                }
        }
        }
}

// MODULE & FUNKTIONEN------------------------
module herringbone( number_of_teeth=15, circular_pitch=10, pressure_angle=28, depth_ratio=1, clearance=0, helix_angle=0, gear_thickness=5)
{
        union()
        {
                gear(number_of_teeth, circular_pitch, pressure_angle, depth_ratio, clearance, helix_angle, gear_thickness/2);
                mirror([0,0,1])
                        gear(number_of_teeth, circular_pitch, pressure_angle, depth_ratio, clearance, helix_angle, gear_thickness/2);
        }
}

module gear( number_of_teeth=15, circular_pitch=10, pressure_angle=28, depth_ratio=1, clearance=0, helix_angle=0, gear_thickness=5, flat=false)
{
        pitch_radius = number_of_teeth*circular_pitch/(2*PiExact);
        twist=tan(helix_angle)*gear_thickness/pitch_radius*180/PiExact;

        flat_extrude(h=gear_thickness,twist=twist,flat=flat)
                gear2D( number_of_teeth, circular_pitch, pressure_angle, depth_ratio, clearance);
}

module flat_extrude(h,twist,flat)
{
        if(flat==false)
                linear_extrude(height=h,twist=twist,slices=Precision)
            children(0);
        else
                children(0);
}

module gear2D( number_of_teeth, circular_pitch, pressure_angle, depth_ratio, clearance)
{
        pitch_radius                 = number_of_teeth*circular_pitch/(2*PiExact);
        base_radius                 = pitch_radius*cos(pressure_angle);
        depth                                 = circular_pitch/(2*tan(pressure_angle));
        outer_radius                 = clearance<0 ? pitch_radius+depth/2-clearance : pitch_radius+depth/2;
        root_radius1                 = pitch_radius-depth/2-clearance/2;
        root_radius                 = (clearance<0 && root_radius1<base_radius) ? base_radius : root_radius1;
        backlash_angle                 = clearance/(pitch_radius*cos(pressure_angle)) * 180 / PiExact;
        half_thick_angle        = 90/number_of_teeth - backlash_angle/2;
        pitch_point                 = involute (base_radius, involute_intersect_angle (base_radius, pitch_radius));
        pitch_angle                 = atan2 (pitch_point[1], pitch_point[0]);
        min_radius                         = max (base_radius,root_radius);

        intersection()
        {
                rotate(90/number_of_teeth)
                        circle($fn=number_of_teeth*3,r=pitch_radius+depth_ratio*circular_pitch/2-clearance/2);
                union()
                {
                        rotate(90/number_of_teeth)
                                circle($fn=number_of_teeth*2, r=max(root_radius,pitch_radius-depth_ratio*circular_pitch/2-clearance/2));

                        for (i = [1:number_of_teeth])rotate(i*360/number_of_teeth)
                        {
                                halftooth( pitch_angle, base_radius, min_radius, outer_radius, half_thick_angle);
                                mirror([0,1])
                                        halftooth ( pitch_angle, base_radius, min_radius, outer_radius, half_thick_angle);
                        }
                }
        }
}


module halftooth( pitch_angle, base_radius, min_radius, outer_radius, half_thick_angle)
{
        index = [ for (i = [0 : 1 : Precision]) i ];

        start_angle = max(involute_intersect_angle (base_radius, min_radius)-5,0);
        stop_angle = involute_intersect_angle (base_radius, outer_radius);
        angle = index*(stop_angle-start_angle)/index[len(index)-1];

        p = concat([[0,0]],[for (a = [ 0 : len(angle) - 1 ]) involute(base_radius,angle[a]+start_angle) ]);

        difference(){
                rotate(-pitch_angle-half_thick_angle)polygon(points=p);
                square(2*outer_radius);
        }
}

function involute_intersect_angle(base_radius, radius) = sqrt (pow (radius/base_radius, 2) - 1) * 180 / PiExact;

// Berechnen der Evolventenposition fuer einen gegebenen Basisradius und Evolventenwinkel.
function involute (base_radius, involute_angle) =
[
        base_radius*(cos (involute_angle) + involute_angle*PiExact/180*sin (involute_angle)),
        base_radius*(sin (involute_angle) - involute_angle*PiExact/180*cos (involute_angle))
];

echo("------------------------- END -------------------------");

RAW code

Planetengetriebe 2

Planetengetriebe 3 (parametrierbar)

/*
*******************************************
Objekt Info: Planetengetriebe 3

*******************************************
Version: 18.09.2022 khf
*******************************************
*/

//***************   Auswahl   *************

Module = 1.5; // Groesse

Gear_type = "7"; //Typ
// 1 = Zahnstange
// 2 = Stirnrad
// 3 = Pfeilrad
// 4 = Zahnstange und Stirnrad
// 5 = Hohlrad
// 6 = Pfeilhohlrad
// 7 = Planetengetriebe
// 8 = Kegelrad
// 9 = Kegelradpaar
//10 = Pfeilkegelradpaar
//11 = Trapezgewindestange
//12 = Trapezgewindestange mit Zahnrad

//*****************************************

//***************   Libraries  ************

//Zahnrad-Sammlung.json

//*****************************************

//***************  Parameter   *************

$fn = 96;
width = 5.0; // 0.01
teeth = 30;
bore = 3; // 0.01
straight = false;

//*****************************************

/*
Die Zahnradsammlung enthaelt die Module und Parameter:
- zahnstange(modul, laenge, hoehe, breite, eingriffswinkel=20, schraegungswinkel=0)
- stirnrad(modul, zahnzahl, breite, bohrung, eingriffswinkel=20, schraegungswinkel=0, optimiert=true)
- pfeilrad(modul, zahnzahl, breite, bohrung, eingriffswinkel=20, schraegungswinkel=0, optimiert=true)
- zahnstange_und_rad (modul, laenge_stange, zahnzahl_rad, hoehe_stange, bohrung_rad, breite, eingriffswinkel=20, schraegungswinkel=0, zusammen_gebaut=true, optimiert=true)
- hohlrad(modul, zahnzahl, breite, randbreite, eingriffswinkel=20, schraegungswinkel=0)
- pfeilhohlrad(modul, zahnzahl, breite, randbreite, eingriffswinkel=20, schraegungswinkel=0)
- planetengetriebe(modul, zahnzahl_sonne, zahnzahl_planet, anzahl_planeten, breite, randbreite, bohrung, eingriffswinkel=20, schraegungswinkel=0, zusammen_gebaut=true, optimiert=true)
- kegelrad(modul, zahnzahl,  teilkegelwinkel, zahnbreite, bohrung, eingriffswinkel=20, schraegungswinkel=0)
- pfeilkegelrad(modul, zahnzahl, teilkegelwinkel, zahnbreite, bohrung, eingriffswinkel=20, schraegungswinkel=0)
- kegelradpaar(modul, zahnzahl_rad, zahnzahl_ritzel, achsenwinkel=90, zahnbreite, bohrung, eingriffswinkel = 20, schraegungswinkel=0, zusammen_gebaut=true)
- pfeilkegelradpaar(modul, zahnzahl_rad, zahnzsahl_ritzel, achsenwinkel=90, zahnbreite, bohrung, eingriffswinkel = 20, schraegungswinkel=0, zusammen_gebaut=true)
- schnecke(modul, gangzahl, laenge, bohrung, eingriffswinkel=20, steigungswinkel=10, zusammen_gebaut=true)
- schneckenradsatz(modul, zahnzahl, gangzahl, breite, laenge, bohrung_schnecke, bohrung_rad, eingriffswinkel=20, steigungswinkel=0, optimiert=true, zusammen_gebaut=true)

Erlaubte Module nach DIN 780:
0.05 0.06 0.08 0.10 0.12 0.16
0.20 0.25 0.3  0.4  0.5  0.6
0.7  0.8  0.9  1    1.25 1.5
2    2.5  3    4    5    6
8    10   12   16   20   25
32   40   50   60

*/
/* [Erweiterte Parameter] */
hub = true;
hub_diameter = 6; // 0.01
hub_thickness = 5; // 0.01
// (Gewichtsoptimierung, falls true)
optimized = false;
pressure_angle = 20; // 0.01
helix_angle = 20; // 0.01
clearance = 0.05; // 0.01

/* [Multi-Gear-Konfigurationen] */
idler_teeth = 36;
idler_bore = 3; // 0.01
assembled = true;

/* [Rack-Parameter] */
rack_length = 50; // 0.01
rack_height = 4; // 0.01

/* [Trapezgewindestange Parameter] */
// Trapezgewindestange Gewinde-Steigung
lead_angle = 4; // 0.01
// Anzahl dermGewindegaenge
worm_starts = 1;
// Trapezgewindestange Bohrung
worm_bore = 3; // 0.01
worm_length = 60; // 0.01

/* [Kegelrad Parameter] */
bevel_angle = 45; // 0.01
bevel_width = 5; // 0.01
shaft_angle = 90; // 0.01

/* [Ringfoermige/interne Getriebeparameter] */
rim_width = 3; // 0.01

/* [Parameter des Planetengetriebes] */
solar_teeth = 20;
planet_teeth = 10;
number_of_planets = 3;

//**************   Programm  **************

module customizer_separator() {}

finalHelixAngle = straight ? 0 : helix_angle;
final_hub_diameter = hub ? hub_diameter : 0;
final_hub_thickness = hub ? hub_thickness : 0;


// Allgemeine Variablen
pi = 3.14159;
rad = 57.29578;
spiel = clearance;        // Spiel zwischen Zaehnen

/*        Wandelt Radian in Grad um */
function grad(eingriffswinkel) = eingriffswinkel*rad;

/*        Wandelt Grad in Radian um */
function radian(eingriffswinkel) = eingriffswinkel/rad;

/*        Wandelt 2D-Polarkoordinaten in kartesische um
    Format: radius, phi; phi = Winkel zur x-Achse auf xy-Ebene */
function pol_zu_kart(polvect) = [
        polvect[0]*cos(polvect[1]),
        polvect[0]*sin(polvect[1])
];

/*        Kreisevolventen-Funktion:
    Gibt die Polarkoordinaten einer Kreisevolvente aus
    r = Radius des Grundkreises
    rho = Abrollwinkel in Grad */
function ev(r,rho) = [
        r/cos(rho),
        grad(tan(rho)-radian(rho))
];

/*  Kugelevolventen-Funktion
    Gibt den Azimutwinkel einer Kugelevolvente aus
    theta0 = Polarwinkel des Kegels, an dessen Schnittkante zur Grosskugel die Evolvente abrollt
    theta = Polarwinkel, fuer den der Azimutwinkel der Evolvente berechnet werden soll */
function kugelev(theta0,theta) = 1/sin(theta0)*acos(cos(theta)/cos(theta0))-acos(tan(theta0)/tan(theta));

/*  Wandelt Kugelkoordinaten in kartesische um
    Format: radius, theta, phi; theta = Winkel zu z-Achse, phi = Winkel zur x-Achse auf xy-Ebene */
function kugel_zu_kart(vect) = [
        vect[0]*sin(vect[1])*cos(vect[2]),
        vect[0]*sin(vect[1])*sin(vect[2]),
        vect[0]*cos(vect[1])
];

/*        prueft, ob eine Zahl gerade ist
        = 1, wenn ja
        = 0, wenn die Zahl nicht gerade ist */
function istgerade(zahl) =
        (zahl == floor(zahl/2)*2) ? 1 : 0;

/*        groesster gemeinsamer Teiler
        nach Euklidischem Algorithmus.
        Sortierung: a muss groesser als b sein */
function ggt(a,b) =
        a%b == 0 ? b : ggt(b,a%b);

/*        Polarfunktion mit polarwinkel und zwei variablen */
function spirale(a, r0, phi) =
        a*phi + r0;

/*        Kopiert und dreht einen Koerper */
module kopiere(vect, zahl, abstand, winkel){
        for(i = [0:zahl-1]){
                translate(v=vect*abstand*i)
                        rotate(a=i*winkel, v = [0,0,1])
                                children(0);
        }
}

/*  Zahnstange
    modul = Hoehe des Zahnkopfes ueber der Waelzgeraden
    laenge = Laenge der Zahnstange
    hoehe = Hoehe der Zahnstange bis zur Waelzgeraden
    breite = Breite eines Zahns
    eingriffswinkel = Eingriffswinkel, Standardwert = 20° gemaess DIN 867. Sollte nicht groesser als 45° sein.
    schraegungswinkel = Schraegungswinkel zur Zahnstangen-Querachse; 0° = Geradverzahnung */
module zahnstange(modul, laenge, hoehe, breite, eingriffswinkel = 20, schraegungswinkel = 0) {

        // Dimensions-Berechnungen
        modul=modul*(1-spiel);
        c = modul / 6;                                                                                                // Kopfspiel
        mx = modul/cos(schraegungswinkel);                                                        // Durch Schraegungswinkel verzerrtes modul in x-Richtung
        a = 2*mx*tan(eingriffswinkel)+c*tan(eingriffswinkel);                // Flankenbreite
        b = pi*mx/2-2*mx*tan(eingriffswinkel);                                                // Kopfbreite
        x = breite*tan(schraegungswinkel);                                                        // Verschiebung der Oberseite in x-Richtung durch Schraegungswinkel
        nz = ceil((laenge+abs(2*x))/(pi*mx));                                                // Anzahl der Zaehne

        translate([-pi*mx*(nz-1)/2-a-b/2,-modul,0]){
                intersection(){                                                                                        // Erzeugt ein Prisma, das in eine Quadergeometrie eingepasst wird
                        kopiere([1,0,0], nz, pi*mx, 0){
                                polyhedron(
                                        points=[[0,-c,0], [a,2*modul,0], [a+b,2*modul,0], [2*a+b,-c,0], [pi*mx,-c,0], [pi*mx,modul-hoehe,0], [0,modul-hoehe,0],        // Unterseite
                                                [0+x,-c,breite], [a+x,2*modul,breite], [a+b+x,2*modul,breite], [2*a+b+x,-c,breite], [pi*mx+x,-c,breite], [pi*mx+x,modul-hoehe,breite], [0+x,modul-hoehe,breite]],        // Oberseite
                                        faces=[[6,5,4,3,2,1,0],                                                // Unterseite
                                                [1,8,7,0],
                                                [9,8,1,2],
                                                [10,9,2,3],
                                                [11,10,3,4],
                                                [12,11,4,5],
                                                [13,12,5,6],
                                                [7,13,6,0],
                                                [7,8,9,10,11,12,13],                                        // Oberseite
                                        ]
                                );
                        };
                        translate([abs(x),-hoehe+modul-0.5,-0.5]){
                                cube([laenge,hoehe+modul+1,breite+1]);                        // Quader, der das Volumen der Zahnstange umfasst
                        }
                };
        };
}

/*  Stirnrad
    modul = Hoehe des Zahnkopfes ueber dem Teilkreis
    zahnzahl = Anzahl der Radzaehne
    breite = Zahnbreite
    bohrung = Durchmesser der Mittelbohrung
    eingriffswinkel = Eingriffswinkel, Standardwert = 20° gemaess DIN 867. Sollte nicht groesser als 45° sein.
    schraegungswinkel = Schraegungswinkel zur Rotationsachse; 0° = Geradverzahnung
        optimiert = Loecher zur Material-/Gewichtsersparnis bzw. Oberflaechenvergoesserung erzeugen, wenn Geometrie erlaubt */
module stirnrad(modul, zahnzahl, breite, bohrung, nabendicke=0, nabendurchmesser=0, eingriffswinkel = 20, schraegungswinkel = 0, optimiert = true) {

        // Dimensions-Berechnungen
        d = modul * zahnzahl;                                                                                        // Teilkreisdurchmesser
        r = d / 2;                                                                                                                // Teilkreisradius
        alpha_stirn = atan(tan(eingriffswinkel)/cos(schraegungswinkel));// Schraegungswinkel im Stirnschnitt
        db = d * cos(alpha_stirn);                                                                                // Grundkreisdurchmesser
        rb = db / 2;                                                                                                        // Grundkreisradius
        da = (modul <1)? d + modul * 2.2 : d + modul * 2;                                // Kopfkreisdurchmesser nach DIN 58400 bzw. DIN 867
        ra = da / 2;                                                                                                        // Kopfkreisradius
        c =  (zahnzahl <3)? 0 : modul/6;                                                                // Kopfspiel
        df = d - 2 * (modul + c);                                                                                // Fusskreisdurchmesser
        rf = df / 2;                                                                                                        // Fusskreisradius
        rho_ra = acos(rb/ra);                                                                                        // maximaler Abrollwinkel;
                                                                                                                                        // Evolvente beginnt auf Grundkreis und endet an Kopfkreis
        rho_r = acos(rb/r);                                                                                                // Abrollwinkel am Teilkreis;
                                                                                                                                        // Evolvente beginnt auf Grundkreis und endet an Kopfkreis
        phi_r = grad(tan(rho_r)-radian(rho_r));                                                        // Winkel zum Punkt der Evolvente auf Teilkreis
        gamma = rad*breite/(r*tan(90-schraegungswinkel));                                // Torsionswinkel fuer Extrusion
        schritt = rho_ra/16;                                                                                        // Evolvente wird in 16 Stuecke geteilt
        tau = 360/zahnzahl;                                                                                                // Teilungswinkel

        r_loch = (2*rf - bohrung)/8;                                                                        // Radius der Loecher fuer Material-/Gewichtsersparnis
        rm = bohrung/2+2*r_loch;                                                                                // Abstand der Achsen der Loecher von der Hauptachse
        z_loch = floor(2*pi*rm/(3*r_loch));                                                                // Anzahl der Loecher fuer Material-/Gewichtsersparnis

        optimiert = (optimiert && r >= breite*1.5 && d > 2*bohrung);        // ist Optimierung sinnvoll?

        // Zeichnung
        union(){
                rotate([0,0,-phi_r-90*(1-spiel)/zahnzahl]){                                                // Zahn auf x-Achse zentrieren;
                                                                                                                                                // macht Ausrichtung mit anderen Raedern einfacher

                        linear_extrude(height = breite, twist = gamma){
                                difference(){
                                        union(){
                                                zahnbreite = (180*(1-spiel))/zahnzahl+2*phi_r;
                                                circle(rf);                                                                                // Fusskreis
                                                for (rot = [0:tau:360]){
                                                        rotate (rot){                                                                // "Zahnzahl-mal" kopieren und drehen
                                                                polygon(concat(                                                        // Zahn
                                                                        [[0,0]],                                                        // Zahnsegment beginnt und endet im Ursprung
                                                                        [for (rho = [0:schritt:rho_ra])                // von null Grad (Grundkreis)
                                                                                                                                                // bis maximalen Evolventenwinkel (Kopfkreis)
                                                                                pol_zu_kart(ev(rb,rho))],                // Erste Evolventen-Flanke

                                                                        [pol_zu_kart(ev(rb,rho_ra))],                // Punkt der Evolvente auf Kopfkreis

                                                                        [for (rho = [rho_ra:-schritt:0])        // von maximalen Evolventenwinkel (Kopfkreis)
                                                                                                                                                // bis null Grad (Grundkreis)
                                                                                pol_zu_kart([ev(rb,rho)[0], zahnbreite-ev(rb,rho)[1]])]
                                                                                                                                                // Zweite Evolventen-Flanke
                                                                                                                                                // (180*(1-spiel)) statt 180 Grad,
                                                                                                                                                // um Spiel an den Flanken zu erlauben
                                                                        )
                                                                );
                                                        }
                                                }
                                        }
                                        circle(r = rm+r_loch*1.49);                                                        // "Bohrung"
                                }
                        }
                }
                // mit Materialersparnis
                if (optimiert) {
                        linear_extrude(height = breite){
                                difference(){
                                                circle(r = (bohrung+r_loch)/2);
                                                circle(r = bohrung/2);                                                        // Bohrung
                                        }
                                }
                        linear_extrude(height = (breite-r_loch/2 < breite*2/3) ? breite*2/3 : breite-r_loch/2){
                                difference(){
                                        circle(r=rm+r_loch*1.51);
                                        union(){
                                                circle(r=(bohrung+r_loch)/2);
                                                for (i = [0:1:z_loch]){
                                                        translate(kugel_zu_kart([rm,90,i*360/z_loch]))
                                                                circle(r = r_loch);
                                                }
                                        }
                                }
                        }
                }
                // ohne Materialersparnis
                else {
                        difference(){
                union(){
                    linear_extrude(height = breite){
                        circle(r = rm+r_loch*1.51);
                    }
                    linear_extrude(height = breite+nabendicke){
                        circle(r = nabendurchmesser/2);
                    }
                }
                translate([0,0,-breite/2]){
                    linear_extrude(height = (breite+nabendicke)*2){
                        circle(r = bohrung/2);
                    }
                }
            }
                }
        }
}

/*  Pfeilrad; verwendet das Modul "stirnrad"
    modul = Hoehe des Zahnkopfes ueber dem Teilkreis
    zahnzahl = Anzahl der Radzaehne
    breite = Zahnbreite
    bohrung = Durchmesser der Mittelbohrung
    eingriffswinkel = Eingriffswinkel, Standardwert = 20° gemaess DIN 867. Sollte nicht groesser als 45° sein.
    schraegungswinkel = Schraegungswinkel zur Rotationsachse, Standardwert = 0° (Geradverzahnung)
        optimiert = Loecher zur Material-/Gewichtsersparnis */
module pfeilrad(modul, zahnzahl, breite, bohrung, nabendicke, nabendurchmesser, eingriffswinkel = 20, schraegungswinkel=0, optimiert=true){

        breite = breite/2;
        d = modul * zahnzahl;                                                                                        // Teilkreisdurchmesser
        r = d / 2;                                                                                                                // Teilkreisradius
        c =  (zahnzahl <3)? 0 : modul/6;                                                                // Kopfspiel

        df = d - 2 * (modul + c);                                                                                // Fusskreisdurchmesser
        rf = df / 2;                                                                                                        // Fusskreisradius

        r_loch = (2*rf - bohrung)/8;                                                                        // Radius der Loecher fuer Material-/Gewichtsersparnis
        rm = bohrung/2+2*r_loch;                                                                                // Abstand der Achsen der Loecher von der Hauptachse
        z_loch = floor(2*pi*rm/(3*r_loch));                                                                // Anzahl der Loecher fuer Material-/Gewichtsersparnis

        optimiert = (optimiert && r >= breite*3 && d > 2*bohrung);                // ist Optimierung sinnvoll?

        translate([0,0,breite]){
                union(){
                        stirnrad(modul, zahnzahl, breite, 2*(rm+r_loch*1.49), nabendicke, nabendurchmesser, eingriffswinkel, schraegungswinkel, false);                // untere Haelfte
                        mirror([0,0,1]){
                                stirnrad(modul, zahnzahl, breite, 2*(rm+r_loch*1.49), nabendicke, nabendurchmesser, eingriffswinkel, schraegungswinkel, false);        // obere Haelfte
                        }
                }
        }
        // mit Materialersparnis
        if (optimiert) {
                linear_extrude(height = breite*2){
                        difference(){
                                        circle(r = (bohrung+r_loch)/2);
                                        circle(r = bohrung/2);                                                        // Bohrung
                                }
                        }
                linear_extrude(height = (2*breite-r_loch/2 < 1.33*breite) ? 1.33*breite : 2*breite-r_loch/2){ //breite*4/3
                        difference(){
                                circle(r=rm+r_loch*1.51);
                                union(){
                                        circle(r=(bohrung+r_loch)/2);
                                        for (i = [0:1:z_loch]){
                                                translate(kugel_zu_kart([rm,90,i*360/z_loch]))
                                                        circle(r = r_loch);
                                        }
                                }
                        }
                }
        }
        // ohne Materialersparnis
        else {
        difference(){
            union(){
                linear_extrude(height = breite*2){
                    circle(r = rm+r_loch*1.51);
                }
                linear_extrude(height = breite*2+nabendicke){
                    circle(r = nabendurchmesser/2);
                }
            }
            translate([0,0,-breite/2]){
                linear_extrude(height = (breite*2+nabendicke)*2){
                    circle(r = bohrung/2);
                }
            }
        }
        }
}

/*        Zahnstange und -Rad
    modul = Hoehe des Zahnkopfes ueber dem Teilkreis
    laenge_stange = Laenge der Zahnstange
    zahnzahl_rad = Anzahl der Radzaehne
        hoehe_stange = Hoehe der Zahnstange bis zur Waelzgeraden
    bohrung_rad = Durchmesser der Mittelbohrung des Stirnrads
        breite = Breite eines Zahns
    eingriffswinkel = Eingriffswinkel, Standardwert = 20° gemaess DIN 867. Sollte nicht groesser als 45° sein.
    schraegungswinkel = Schraegungswinkel zur Rotationsachse, Standardwert = 0° (Geradverzahnung) */
module zahnstange_und_rad (modul, laenge_stange, zahnzahl_rad, hoehe_stange, bohrung_rad, breite, nabendicke, nabendurchmesser, eingriffswinkel=20, schraegungswinkel=0, zusammen_gebaut=true, optimiert=true) {

        abstand = zusammen_gebaut? modul*zahnzahl_rad/2 : modul*zahnzahl_rad;

        zahnstange(modul, laenge_stange, hoehe_stange, breite, eingriffswinkel, -schraegungswinkel);
        translate([0,abstand,0])
                rotate(a=360/zahnzahl_rad)
                        stirnrad (modul, zahnzahl_rad, breite, bohrung_rad, nabendicke, nabendurchmesser, eingriffswinkel, schraegungswinkel, optimiert);
}

/*        Hohlrad
    modul = Hoehe des Zahnkopfes ueber dem Teilkreis
    zahnzahl = Anzahl der Radzaehne
    breite = Zahnbreite
        randbreite = Breite des Randes ab Fusskreis
    bohrung = Durchmesser der Mittelbohrung
    eingriffswinkel = Eingriffswinkel, Standardwert = 20° gemaess DIN 867. Sollte nicht groesser als 45° sein.
    schraegungswinkel = Schraegungswinkel zur Rotationsachse, Standardwert = 0° (Geradverzahnung) */
module hohlrad(modul, zahnzahl, breite, randbreite, eingriffswinkel = 20, schraegungswinkel = 0) {

        // Dimensions-Berechnungen
        ha = (zahnzahl >= 20) ? 0.02 * atan((zahnzahl/15)/pi) : 0.6;        // Verkuerzungsfaktor Zahnkopfhoehe
        d = modul * zahnzahl;                                                                                        // Teilkreisdurchmesser
        r = d / 2;                                                                                                                // Teilkreisradius
        alpha_stirn = atan(tan(eingriffswinkel)/cos(schraegungswinkel));// Schraegungswinkel im Stirnschnitt
        db = d * cos(alpha_stirn);                                                                                // Grundkreisdurchmesser
        rb = db / 2;                                                                                                        // Grundkreisradius
        c = modul / 6;                                                                                                        // Kopfspiel
        da = (modul <1)? d + (modul+c) * 2.2 : d + (modul+c) * 2;                // Kopfkreisdurchmesser
        ra = da / 2;                                                                                                        // Kopfkreisradius
        df = d - 2 * modul * ha;                                                                                // Fusskreisdurchmesser
        rf = df / 2;                                                                                                        // Fusskreisradius
        rho_ra = acos(rb/ra);                                                                                        // maximaler Evolventenwinkel;
                                                                                                                                        // Evolvente beginnt auf Grundkreis und endet an Kopfkreis
        rho_r = acos(rb/r);                                                                                                // Evolventenwinkel am Teilkreis;
                                                                                                                                        // Evolvente beginnt auf Grundkreis und endet an Kopfkreis
        phi_r = grad(tan(rho_r)-radian(rho_r));                                                        // Winkel zum Punkt der Evolvente auf Teilkreis
        gamma = rad*breite/(r*tan(90-schraegungswinkel));                                // Torsionswinkel fuer Extrusion
        schritt = rho_ra/16;                                                                                        // Evolvente wird in 16 Stuecke geteilt
        tau = 360/zahnzahl;                                                                                                // Teilungswinkel

        // Zeichnung
        rotate([0,0,-phi_r-90*(1+spiel)/zahnzahl])                                                // Zahn auf x-Achse zentrieren;
                                                                                                                                        // macht Ausrichtung mit anderen Raedern einfacher
        linear_extrude(height = breite, twist = gamma){
                difference(){
                        circle(r = ra + randbreite);                                                        // Aussenkreis
                        union(){
                                zahnbreite = (180*(1+spiel))/zahnzahl+2*phi_r;
                                circle(rf);                                                                                        // Fusskreis
                                for (rot = [0:tau:360]){
                                        rotate (rot) {                                                                        // "Zahnzahl-mal" kopieren und drehen
                                                polygon( concat(
                                                        [[0,0]],
                                                        [for (rho = [0:schritt:rho_ra])                        // von null Grad (Grundkreis)
                                                                                                                                        // bis maximaler Evolventenwinkel (Kopfkreis)
                                                                pol_zu_kart(ev(rb,rho))],
                                                        [pol_zu_kart(ev(rb,rho_ra))],
                                                        [for (rho = [rho_ra:-schritt:0])                // von maximaler Evolventenwinkel (Kopfkreis)
                                                                                                                                        // bis null Grad (Grundkreis)
                                                                pol_zu_kart([ev(rb,rho)[0], zahnbreite-ev(rb,rho)[1]])]
                                                                                                                                        // (180*(1+spiel)) statt 180,
                                                                                                                                        // um Spiel an den Flanken zu erlauben
                                                        )
                                                );
                                        }
                                }
                        }
                }
        }

        echo("Aussendurchmesser Hohlrad = ", 2*(ra + randbreite));

}

/*  Pfeil-Hohlrad; verwendet das Modul "hohlrad"
    modul = Hoehe des Zahnkopfes ueber dem Teilkegel
    zahnzahl = Anzahl der Radzaehne
    breite = Zahnbreite
    bohrung = Durchmesser der Mittelbohrung
    eingriffswinkel = Eingriffswinkel, Standardwert = 20° gemaess DIN 867. Sollte nicht groesser als 45° sein.
    schraegungswinkel = Schraegungswinkel zur Rotationsachse, Standardwert = 0° (Geradverzahnung) */
module pfeilhohlrad(modul, zahnzahl, breite, randbreite, eingriffswinkel = 20, schraegungswinkel = 0) {

        breite = breite / 2;
        translate([0,0,breite])
                union(){
                hohlrad(modul, zahnzahl, breite, randbreite, eingriffswinkel, schraegungswinkel);                // untere Haelfte
                mirror([0,0,1])
                        hohlrad(modul, zahnzahl, breite, randbreite, eingriffswinkel, schraegungswinkel);        // obere Haelfte
        }
}

/*        Planetengetriebe; verwendet die Module "pfeilrad" und "pfeilhohlrad"
    modul = Hoehe des Zahnkopfes ueber dem Teilkegel
    zahnzahl_sonne = Anzahl der Zaehne des Sonnenrads
    zahnzahl_planet = Anzahl der Zaehne eines Planetenrads
    anzahl_planeten = Anzahl der Planetenraeder. Wenn null, rechnet die Funktion die Mindestanzahl aus.
    breite = Zahnbreite
        randbreite = Breite des Randes ab Fusskreis
    bohrung = Durchmesser der Mittelbohrung
    eingriffswinkel = Eingriffswinkel, Standardwert = 20° gemaess DIN 867. Sollte nicht groesser als 45° sein.
    schraegungswinkel = Schraegungswinkel zur Rotationsachse, Standardwert = 0° (Geradverzahnung)
        zusammen_gebaut =
        optimiert = Loecher zur Material-/Gewichtsersparnis bzw. Oberflaechenvergoesserung erzeugen, wenn Geometrie erlaubt
        zusammen_gebaut = Komponenten zusammengebaut fuer Konstruktion oder auseinander zum 3D-Druck        */
module planetengetriebe(modul, zahnzahl_sonne, zahnzahl_planet, anzahl_planeten, breite, randbreite, bohrung, eingriffswinkel=20, schraegungswinkel=0, zusammen_gebaut=true, optimiert=true){

        // Dimensions-Berechnungen
        d_sonne = modul*zahnzahl_sonne;                                                                                // Teilkreisdurchmesser Sonne
        d_planet = modul*zahnzahl_planet;                                                                        // Teilkreisdurchmesser Planeten
        achsabstand = modul*(zahnzahl_sonne +  zahnzahl_planet) / 2;                // Abstand von Sonnenrad-/Hohlradachse und Planetenachse
        zahnzahl_hohlrad = zahnzahl_sonne + 2*zahnzahl_planet;                                // Anzahl der Zaehne des Hohlrades
    d_hohlrad = modul*zahnzahl_hohlrad;                                                                        // Teilkreisdurchmesser Hohlrad

        drehen = istgerade(zahnzahl_planet);                                                                // Muss das Sonnenrad gedreht werden?

        n_max = floor(180/asin(modul*(zahnzahl_planet)/(modul*(zahnzahl_sonne +  zahnzahl_planet))));
                                                                                                                                                // Anzahl Planetenraeder: hoechstens so viele, wie ohne
                                                                                                                                                // ueberlappung moeglich

        // Zeichnung
        rotate([0,0,180/zahnzahl_sonne*drehen]){
                pfeilrad (modul, zahnzahl_sonne, breite, bohrung, nabendicke=0, nabendurchmesser=0, eingriffswinkel=eingriffswinkel, schraegungswinkel=-schraegungswinkel, optimiert=optimiert);                // Sonnenrad
        }

        if (zusammen_gebaut){
        if(anzahl_planeten==0){
            list = [ for (n=[2 : 1 : n_max]) if ((((zahnzahl_hohlrad+zahnzahl_sonne)/n)==floor((zahnzahl_hohlrad+zahnzahl_sonne)/n))) n];
            anzahl_planeten = list[0];                                                                                // Ermittele Anzahl Planetenraeder
             achsabstand = modul*(zahnzahl_sonne + zahnzahl_planet)/2;                // Abstand von Sonnenrad-/Hohlradachse
            for(n=[0:1:anzahl_planeten-1]){
                translate(kugel_zu_kart([achsabstand,90,360/anzahl_planeten*n]))
                                        rotate([0,0,n*360*d_sonne/d_planet])
                                                pfeilrad (modul, zahnzahl_planet, breite, bohrung, nabendicke=0, nabendurchmesser=0, eingriffswinkel=eingriffswinkel, schraegungswinkel=schraegungswinkel);        // Planetenraeder
            }
       }
       else{
            achsabstand = modul*(zahnzahl_sonne + zahnzahl_planet)/2;                // Abstand von Sonnenrad-/Hohlradachse
            for(n=[0:1:anzahl_planeten-1]){
                translate(kugel_zu_kart([achsabstand,90,360/anzahl_planeten*n]))
                rotate([0,0,n*360*d_sonne/(d_planet)])
                    pfeilrad (modul, zahnzahl_planet, breite, bohrung, nabendicke=0, nabendurchmesser=0, eingriffswinkel=eingriffswinkel, schraegungswinkel=schraegungswinkel);        // Planetenraeder
            }
                }
        }
        else{
                planetenabstand = zahnzahl_hohlrad*modul/2+randbreite+d_planet;                // Abstand Planeten untereinander
                for(i=[-(anzahl_planeten-1):2:(anzahl_planeten-1)]){
                        translate([planetenabstand, d_planet*i,0])
                                pfeilrad (modul, zahnzahl_planet, breite, bohrung, nabendicke=0, nabendurchmesser=0, eingriffswinkel=eingriffswinkel, schraegungswinkel=schraegungswinkel);        // Planetenraeder
                }
        }

        pfeilhohlrad (modul, zahnzahl_hohlrad, breite, randbreite, eingriffswinkel, schraegungswinkel); // Hohlrad

}

/*  Kegelrad
    modul = Hoehe des Zahnkopfes ueber dem Teilkegel; Angabe fuer die Aussenseite des Kegels
    zahnzahl = Anzahl der Radzaehne
    teilkegelwinkel = (Halb)winkel des Kegels, auf dem das jeweils andere Hohlrad abrollt
    zahnbreite = Breite der Zaehne von der Aussenseite in Richtung Kegelspitze
    bohrung = Durchmesser der Mittelbohrung
    eingriffswinkel = Eingriffswinkel, Standardwert = 20° gemaess DIN 867. Sollte nicht groesser als 45° sein.
        schraegungswinkel = Schraegungswinkel, Standardwert = 0° */
module kegelrad(modul, zahnzahl, teilkegelwinkel, zahnbreite, bohrung, eingriffswinkel = 20, schraegungswinkel=0) {

        // Dimensions-Berechnungen
        d_aussen = modul * zahnzahl;                                                                        // Teilkegeldurchmesser auf der Kegelgrundflaeche,
                                                                                                                                        // entspricht der Sehne im Kugelschnitt
        r_aussen = d_aussen / 2;                                                                                // Teilkegelradius auf der Kegelgrundflaeche
        rg_aussen = r_aussen/sin(teilkegelwinkel);                                                // Grosskegelradius fuer Zahn-Aussenseite, entspricht der Laenge der Kegelflanke;
        rg_innen = rg_aussen - zahnbreite;                                                                // Grosskegelradius fuer Zahn-Innenseite
        r_innen = r_aussen*rg_innen/rg_aussen;
        alpha_stirn = atan(tan(eingriffswinkel)/cos(schraegungswinkel));// Schraegungswinkel im Stirnschnitt
        delta_b = asin(cos(alpha_stirn)*sin(teilkegelwinkel));                        // Grundkegelwinkel
        da_aussen = (modul <1)? d_aussen + (modul * 2.2) * cos(teilkegelwinkel): d_aussen + modul * 2 * cos(teilkegelwinkel);
        ra_aussen = da_aussen / 2;
        delta_a = asin(ra_aussen/rg_aussen);
        c = modul / 6;                                                                                                        // Kopfspiel
        df_aussen = d_aussen - (modul +c) * 2 * cos(teilkegelwinkel);
        rf_aussen = df_aussen / 2;
        delta_f = asin(rf_aussen/rg_aussen);
        rkf = rg_aussen*sin(delta_f);                                                                        // Radius des Kegelfusses
        hoehe_f = rg_aussen*cos(delta_f);                                                                // Hoehe des Kegels vom Fusskegel

        echo("Teilkegeldurchmesser auf der Kegelgrundflaeche = ", d_aussen);

        // Groessen fuer Komplementaer-Kegelstumpf
        hoehe_k = (rg_aussen-zahnbreite)/cos(teilkegelwinkel);                        // Hoehe des Komplementaerkegels fuer richtige Zahnlaenge
        rk = (rg_aussen-zahnbreite)/sin(teilkegelwinkel);                                // Fussradius des Komplementaerkegels
        rfk = rk*hoehe_k*tan(delta_f)/(rk+hoehe_k*tan(delta_f));                // Kopfradius des Zylinders fuer
                                                                                                                                        // Komplementaer-Kegelstumpf
        hoehe_fk = rk*hoehe_k/(hoehe_k*tan(delta_f)+rk);                                // Hoehe des Komplementaer-Kegelstumpfs

        echo("Hoehe Kegelrad = ", hoehe_f-hoehe_fk);

        phi_r = kugelev(delta_b, teilkegelwinkel);                                                // Winkel zum Punkt der Evolvente auf Teilkegel

        // Torsionswinkel gamma aus Schraegungswinkel
        gamma_g = 2*atan(zahnbreite*tan(schraegungswinkel)/(2*rg_aussen-zahnbreite));
        gamma = 2*asin(rg_aussen/r_aussen*sin(gamma_g/2));

        schritt = (delta_a - delta_b)/16;
        tau = 360/zahnzahl;                                                                                                // Teilungswinkel
        start = (delta_b > delta_f) ? delta_b : delta_f;
        spiegelpunkt = (180*(1-spiel))/zahnzahl+2*phi_r;

        // Zeichnung
        rotate([0,0,phi_r+90*(1-spiel)/zahnzahl]){                                                // Zahn auf x-Achse zentrieren;
                                                                                                                                        // macht Ausrichtung mit anderen Raedern einfacher
                translate([0,0,hoehe_f]) rotate(a=[0,180,0]){
                        union(){
                                translate([0,0,hoehe_f]) rotate(a=[0,180,0]){                                                                // Kegelstumpf
                                        difference(){
                                                linear_extrude(height=hoehe_f-hoehe_fk, scale=rfk/rkf) circle(rkf*1.001); // 1 promille ueberlappung mit Zahnfuss
                                                translate([0,0,-1]){
                                                        cylinder(h = hoehe_f-hoehe_fk+2, r = bohrung/2);                                // Bohrung
                                                }
                                        }
                                }
                                for (rot = [0:tau:360]){
                                        rotate (rot) {                                                                                                                        // "Zahnzahl-mal" kopieren und drehen
                                                union(){
                                                        if (delta_b > delta_f){
                                                                // Zahnfuss
                                                                flankenpunkt_unten = 1*spiegelpunkt;
                                                                flankenpunkt_oben = kugelev(delta_f, start);
                                                                polyhedron(
                                                                        points = [
                                                                                kugel_zu_kart([rg_aussen, start*1.001, flankenpunkt_unten]),        // 1 promille ueberlappung mit Zahn
                                                                                kugel_zu_kart([rg_innen, start*1.001, flankenpunkt_unten+gamma]),
                                                                                kugel_zu_kart([rg_innen, start*1.001, spiegelpunkt-flankenpunkt_unten+gamma]),
                                                                                kugel_zu_kart([rg_aussen, start*1.001, spiegelpunkt-flankenpunkt_unten]),
                                                                                kugel_zu_kart([rg_aussen, delta_f, flankenpunkt_unten]),
                                                                                kugel_zu_kart([rg_innen, delta_f, flankenpunkt_unten+gamma]),
                                                                                kugel_zu_kart([rg_innen, delta_f, spiegelpunkt-flankenpunkt_unten+gamma]),
                                                                                kugel_zu_kart([rg_aussen, delta_f, spiegelpunkt-flankenpunkt_unten])
                                                                        ],
                                                                        faces = [[0,1,2],[0,2,3],[0,4,1],[1,4,5],[1,5,2],[2,5,6],[2,6,3],[3,6,7],[0,3,7],[0,7,4],[4,6,5],[4,7,6]],
                                                                        convexity =1
                                                                );
                                                        }
                                                        // Zahn
                                                        for (delta = [start:schritt:delta_a-schritt]){
                                                                flankenpunkt_unten = kugelev(delta_b, delta);
                                                                flankenpunkt_oben = kugelev(delta_b, delta+schritt);
                                                                polyhedron(
                                                                        points = [
                                                                                kugel_zu_kart([rg_aussen, delta, flankenpunkt_unten]),
                                                                                kugel_zu_kart([rg_innen, delta, flankenpunkt_unten+gamma]),
                                                                                kugel_zu_kart([rg_innen, delta, spiegelpunkt-flankenpunkt_unten+gamma]),
                                                                                kugel_zu_kart([rg_aussen, delta, spiegelpunkt-flankenpunkt_unten]),
                                                                                kugel_zu_kart([rg_aussen, delta+schritt, flankenpunkt_oben]),
                                                                                kugel_zu_kart([rg_innen, delta+schritt, flankenpunkt_oben+gamma]),
                                                                                kugel_zu_kart([rg_innen, delta+schritt, spiegelpunkt-flankenpunkt_oben+gamma]),
                                                                                kugel_zu_kart([rg_aussen, delta+schritt, spiegelpunkt-flankenpunkt_oben])
                                                                        ],
                                                                        faces = [[0,1,2],[0,2,3],[0,4,1],[1,4,5],[1,5,2],[2,5,6],[2,6,3],[3,6,7],[0,3,7],[0,7,4],[4,6,5],[4,7,6]],
                                                                        convexity =1
                                                                );
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }
}

/*  Pfeil-Kegelrad; verwendet das Modul "kegelrad"
    modul = Hoehe des Zahnkopfes ueber dem Teilkreis
    zahnzahl = Anzahl der Radzaehne
    teilkegelwinkel, zahnbreite
    bohrung = Durchmesser der Mittelbohrung
    eingriffswinkel = Eingriffswinkel, Standardwert = 20° gemaess DIN 867. Sollte nicht groesser als 45° sein.
    schraegungswinkel = Schraegungswinkel, Standardwert = 0° */
module pfeilkegelrad(modul, zahnzahl, teilkegelwinkel, zahnbreite, bohrung, eingriffswinkel = 20, schraegungswinkel=0){

        // Dimensions-Berechnungen

        zahnbreite = zahnbreite / 2;

        d_aussen = modul * zahnzahl;                                                                // Teilkegeldurchmesser auf der Kegelgrundflaeche,
                                                                                                                                // entspricht der Sehne im Kugelschnitt
        r_aussen = d_aussen / 2;                                                                        // Teilkegelradius auf der Kegelgrundflaeche
        rg_aussen = r_aussen/sin(teilkegelwinkel);                                        // Grosskegelradius, entspricht der Laenge der Kegelflanke;
        c = modul / 6;                                                                                                // Kopfspiel
        df_aussen = d_aussen - (modul +c) * 2 * cos(teilkegelwinkel);
        rf_aussen = df_aussen / 2;
        delta_f = asin(rf_aussen/rg_aussen);
        hoehe_f = rg_aussen*cos(delta_f);                                                        // Hoehe des Kegels vom Fusskegel

        // Torsionswinkel gamma aus Schraegungswinkel
        gamma_g = 2*atan(zahnbreite*tan(schraegungswinkel)/(2*rg_aussen-zahnbreite));
        gamma = 2*asin(rg_aussen/r_aussen*sin(gamma_g/2));

        echo("Teilkegeldurchmesser auf der Kegelgrundflaeche = ", d_aussen);

        // Groessen fuer Komplementaer-Kegelstumpf
        hoehe_k = (rg_aussen-zahnbreite)/cos(teilkegelwinkel);                // Hoehe des Komplementaerkegels fuer richtige Zahnlaenge
        rk = (rg_aussen-zahnbreite)/sin(teilkegelwinkel);                        // Fussradius des Komplementaerkegels
        rfk = rk*hoehe_k*tan(delta_f)/(rk+hoehe_k*tan(delta_f));        // Kopfradius des Zylinders fuer
                                                                                                                                // Komplementaer-Kegelstumpf
        hoehe_fk = rk*hoehe_k/(hoehe_k*tan(delta_f)+rk);                        // Hoehe des Komplementaer-Kegelstumpfs

        modul_innen = modul*(1-zahnbreite/rg_aussen);

                union(){
                kegelrad(modul, zahnzahl, teilkegelwinkel, zahnbreite, bohrung, eingriffswinkel, schraegungswinkel);                // untere Haelfte
                translate([0,0,hoehe_f-hoehe_fk])
                        rotate(a=-gamma,v=[0,0,1])
                                kegelrad(modul_innen, zahnzahl, teilkegelwinkel, zahnbreite, bohrung, eingriffswinkel, -schraegungswinkel);        // obere Haelfte
        }
}

/*  Spiral-Kegelrad; verwendet das Modul "kegelrad"
    modul = Hoehe des Zahnkopfes ueber dem Teilkreis
    zahnzahl = Anzahl der Radzaehne
    hoehe = Hoehe des Zahnrads
    bohrung = Durchmesser der Mittelbohrung
    eingriffswinkel = Eingriffswinkel, Standardwert = 20° gemaess DIN 867. Sollte nicht groesser als 45° sein.
    schraegungswinkel = Schraegungswinkel, Standardwert = 0° */
module spiralkegelrad(modul, zahnzahl, teilkegelwinkel, zahnbreite, bohrung, eingriffswinkel = 20, schraegungswinkel=30){

        schritte = 16;

        // Dimensions-Berechnungen

        b = zahnbreite / schritte;
        d_aussen = modul * zahnzahl;                                                                // Teilkegeldurchmesser auf der Kegelgrundflaeche,
                                                                                                                                // entspricht der Sehne im Kugelschnitt
        r_aussen = d_aussen / 2;                                                                        // Teilkegelradius auf der Kegelgrundflaeche
        rg_aussen = r_aussen/sin(teilkegelwinkel);                                        // Grosskegelradius, entspricht der Laenge der Kegelflanke;
        rg_mitte = rg_aussen-zahnbreite/2;

        echo("Teilkegeldurchmesser auf der Kegelgrundflaeche = ", d_aussen);

        a=tan(schraegungswinkel)/rg_mitte;

        union(){
        for(i=[0:1:schritte-1]){
                r = rg_aussen-i*b;
                schraegungswinkel = a*r;
                modul_r = modul-b*i/rg_aussen;
                translate([0,0,b*cos(teilkegelwinkel)*i])

                        rotate(a=-schraegungswinkel*i,v=[0,0,1])
                                kegelrad(modul_r, zahnzahl, teilkegelwinkel, b, bohrung, eingriffswinkel, schraegungswinkel);        // obere Haelfte
                }
        }
}

/*        Kegelradpaar mit beliebigem Achsenwinkel; verwendet das Modul "kegelrad"
    modul = Hoehe des Zahnkopfes ueber dem Teilkegel; Angabe fuer die Aussenseite des Kegels
    zahnzahl_rad = Anzahl der Radzaehne am Rad
    zahnzahl_ritzel = Anzahl der Radzaehne am Ritzel
        achsenwinkel = Winkel zwischen den Achsen von Rad und Ritzel
    zahnbreite = Breite der Zaehne von der Aussenseite in Richtung Kegelspitze
    bohrung_rad = Durchmesser der Mittelbohrung des Rads
    bohrung_ritzel = Durchmesser der Mittelbohrungen des Ritzels
    eingriffswinkel = Eingriffswinkel, Standardwert = 20° gemaess DIN 867. Sollte nicht groesser als 45° sein.
        schraegungswinkel = Schraegungswinkel, Standardwert = 0°
        zusammen_gebaut = Komponenten zusammengebaut fuer Konstruktion oder auseinander zum 3D-Druck */
module kegelradpaar(modul, zahnzahl_rad, zahnzahl_ritzel, achsenwinkel=90, zahnbreite, bohrung_rad, bohrung_ritzel, eingriffswinkel=20, schraegungswinkel=0, zusammen_gebaut=true){

        // Dimensions-Berechnungen
        r_rad = modul*zahnzahl_rad/2;                                                        // Teilkegelradius des Rads
        delta_rad = atan(sin(achsenwinkel)/(zahnzahl_ritzel/zahnzahl_rad+cos(achsenwinkel)));        // Kegelwinkel des Rads
        delta_ritzel = atan(sin(achsenwinkel)/(zahnzahl_rad/zahnzahl_ritzel+cos(achsenwinkel)));// Kegelwingel des Ritzels
        rg = r_rad/sin(delta_rad);                                                                // Radius der Grosskugel
        c = modul / 6;                                                                                        // Kopfspiel
        df_ritzel = pi*rg*delta_ritzel/90 - 2 * (modul + c);        // Fusskegeldurchmesser auf der Grosskugel
        rf_ritzel = df_ritzel / 2;                                                                // Fusskegelradius auf der Grosskugel
        delta_f_ritzel = rf_ritzel/(pi*rg) * 180;                                // Kopfkegelwinkel
        rkf_ritzel = rg*sin(delta_f_ritzel);                                        // Radius des Kegelfusses
        hoehe_f_ritzel = rg*cos(delta_f_ritzel);                                // Hoehe des Kegels vom Fusskegel

        echo("Kegelwinkel Rad = ", delta_rad);
        echo("Kegelwinkel Ritzel = ", delta_ritzel);

        df_rad = pi*rg*delta_rad/90 - 2 * (modul + c);                        // Fusskegeldurchmesser auf der Grosskugel
        rf_rad = df_rad / 2;                                                                        // Fusskegelradius auf der Grosskugel
        delta_f_rad = rf_rad/(pi*rg) * 180;                                                // Kopfkegelwinkel
        rkf_rad = rg*sin(delta_f_rad);                                                        // Radius des Kegelfusses
        hoehe_f_rad = rg*cos(delta_f_rad);                                                // Hoehe des Kegels vom Fusskegel

        echo("Hoehe Rad = ", hoehe_f_rad);
        echo("Hoehe Ritzel = ", hoehe_f_ritzel);

        drehen = istgerade(zahnzahl_ritzel);

        // Zeichnung
        // Rad
        rotate([0,0,180*(1-spiel)/zahnzahl_rad*drehen])
                kegelrad(modul, zahnzahl_rad, delta_rad, zahnbreite, bohrung_rad, eingriffswinkel, schraegungswinkel);

        // Ritzel
        if (zusammen_gebaut)
                translate([-hoehe_f_ritzel*cos(90-achsenwinkel),0,hoehe_f_rad-hoehe_f_ritzel*sin(90-achsenwinkel)])
                        rotate([0,achsenwinkel,0])
                                kegelrad(modul, zahnzahl_ritzel, delta_ritzel, zahnbreite, bohrung_ritzel, eingriffswinkel, -schraegungswinkel);
        else
                translate([rkf_ritzel*2+modul+rkf_rad,0,0])
                        kegelrad(modul, zahnzahl_ritzel, delta_ritzel, zahnbreite, bohrung_ritzel, eingriffswinkel, -schraegungswinkel);
 }

/*        Pfeil-Kegelradpaar mit beliebigem Achsenwinkel; verwendet das Modul "pfeilkegelrad"
    modul = Hoehe des Zahnkopfes ueber dem Teilkegel; Angabe fuer die Aussenseite des Kegels
    zahnzahl_rad = Anzahl der Radzaehne am Rad
    zahnzahl_ritzel = Anzahl der Radzaehne am Ritzel
        achsenwinkel = Winkel zwischen den Achsen von Rad und Ritzel
    zahnbreite = Breite der Zaehne von der Aussenseite in Richtung Kegelspitze
    bohrung_rad = Durchmesser der Mittelbohrung des Rads
    bohrung_ritzel = Durchmesser der Mittelbohrungen des Ritzels
    eingriffswinkel = Eingriffswinkel, Standardwert = 20° gemaess DIN 867. Sollte nicht groesser als 45° sein.
    schraegungswinkel = Schraegungswinkel, Standardwert = 0°
        zusammen_gebaut = Komponenten zusammengebaut fuer Konstruktion oder auseinander zum 3D-Druck */
module pfeilkegelradpaar(modul, zahnzahl_rad, zahnzahl_ritzel, achsenwinkel=90, zahnbreite, bohrung_rad, bohrung_ritzel, eingriffswinkel = 20, schraegungswinkel=10, zusammen_gebaut=true){

        r_rad = modul*zahnzahl_rad/2;                                                        // Teilkegelradius des Rads
        delta_rad = atan(sin(achsenwinkel)/(zahnzahl_ritzel/zahnzahl_rad+cos(achsenwinkel)));        // Kegelwinkel des Rads
        delta_ritzel = atan(sin(achsenwinkel)/(zahnzahl_rad/zahnzahl_ritzel+cos(achsenwinkel)));// Kegelwingel des Ritzels
        rg = r_rad/sin(delta_rad);                                                                // Radius der Grosskugel
        c = modul / 6;                                                                                        // Kopfspiel
        df_ritzel = pi*rg*delta_ritzel/90 - 2 * (modul + c);        // Fusskegeldurchmesser auf der Grosskugel
        rf_ritzel = df_ritzel / 2;                                                                // Fusskegelradius auf der Grosskugel
        delta_f_ritzel = rf_ritzel/(pi*rg) * 180;                                // Kopfkegelwinkel
        rkf_ritzel = rg*sin(delta_f_ritzel);                                        // Radius des Kegelfusses
        hoehe_f_ritzel = rg*cos(delta_f_ritzel);                                // Hoehe des Kegels vom Fusskegel

        echo("Kegelwinkel Rad = ", delta_rad);
        echo("Kegelwinkel Ritzel = ", delta_ritzel);

        df_rad = pi*rg*delta_rad/90 - 2 * (modul + c);                        // Fusskegeldurchmesser auf der Grosskugel
        rf_rad = df_rad / 2;                                                                        // Fusskegelradius auf der Grosskugel
        delta_f_rad = rf_rad/(pi*rg) * 180;                                                // Kopfkegelwinkel
        rkf_rad = rg*sin(delta_f_rad);                                                        // Radius des Kegelfusses
        hoehe_f_rad = rg*cos(delta_f_rad);                                                // Hoehe des Kegels vom Fusskegel

        echo("Hoehe Rad = ", hoehe_f_rad);
        echo("Hoehe Ritzel = ", hoehe_f_ritzel);

        drehen = istgerade(zahnzahl_ritzel);

        // Rad
        rotate([0,0,180*(1-spiel)/zahnzahl_rad*drehen])
                pfeilkegelrad(modul, zahnzahl_rad, delta_rad, zahnbreite, bohrung_rad, eingriffswinkel, schraegungswinkel);

        // Ritzel
        if (zusammen_gebaut)
                translate([-hoehe_f_ritzel*cos(90-achsenwinkel),0,hoehe_f_rad-hoehe_f_ritzel*sin(90-achsenwinkel)])
                        rotate([0,achsenwinkel,0])
                                pfeilkegelrad(modul, zahnzahl_ritzel, delta_ritzel, zahnbreite, bohrung_ritzel, eingriffswinkel, -schraegungswinkel);
        else
                translate([rkf_ritzel*2+modul+rkf_rad,0,0])
                        pfeilkegelrad(modul, zahnzahl_ritzel, delta_ritzel, zahnbreite, bohrung_ritzel, eingriffswinkel, -schraegungswinkel);

}

/*
Berechnet eine Schnecke / archimedische Schraube.
modul = Hoehe des Schneckenkopfes ueber dem Teilzylinder
gangzahl = Anzahl der Gaenge (Zaehne) der Schnecke
laenge = Laenge der Schnecke
bohrung = Durchmesser der Mittelbohrung
eingriffswinkel = Eingriffswinkel, Standardwert = 20° gemaess DIN 867. Sollte nicht groesser als 45° sein.
steigungswinkel = Steigungswinkel der Schnecke, entspricht 90° minus Schraegungswinkel. Positiver Steigungswinkel = rechtsdrehend.
zusammen_gebaut = Komponenten zusammengebaut fuer Konstruktion oder auseinander zum 3D-Druck */
module schnecke(modul, gangzahl, laenge, bohrung, eingriffswinkel=20, steigungswinkel, zusammen_gebaut=true){

        // Dimensions-Berechnungen
        c = modul / 6;                                                                                                // Kopfspiel
        r = modul*gangzahl/(2*sin(steigungswinkel));                                // Teilzylinder-Radius
        rf = r - modul - c;                                                                                        // Fusszylinder-Radius
        a = modul*gangzahl/(90*tan(eingriffswinkel));                                // Spiralparameter
        tau_max = 180/gangzahl*tan(eingriffswinkel);                                // Winkel von Fuss zu Kopf in der Normalen
        gamma = -rad*laenge/((rf+modul+c)*tan(steigungswinkel));        // Torsionswinkel fuer Extrusion

        schritt = tau_max/16;

        // Zeichnung: extrudiere mit Verwindung eine Flaeche, die von zwei archimedischen Spiralen eingeschlossen wird
        if (zusammen_gebaut) {
                rotate([0,0,tau_max]){
                        linear_extrude(height = laenge, center = false, convexity = 10, twist = gamma){
                                difference(){
                                        union(){
                                                for(i=[0:1:gangzahl-1]){
                                                        polygon(
                                                                concat(
                                                                        [[0,0]],

                                                                        // ansteigende Zahnflanke
                                                                        [for (tau = [0:schritt:tau_max])
                                                                                pol_zu_kart([spirale(a, rf, tau), tau+i*(360/gangzahl)])],

                                                                        // Zahnkopf
                                                                        [for (tau = [tau_max:schritt:180/gangzahl])
                                                                                pol_zu_kart([spirale(a, rf, tau_max), tau+i*(360/gangzahl)])],

                                                                        // absteigende Zahnflanke
                                                                        [for (tau = [180/gangzahl:schritt:(180/gangzahl+tau_max)])
                                                                                pol_zu_kart([spirale(a, rf, 180/gangzahl+tau_max-tau), tau+i*(360/gangzahl)])]
                                                                )
                                                        );
                                                }
                                                circle(rf);
                                        }
                                        circle(bohrung/2); // Mittelbohrung
                                }
                        }
                }
        }
        else {
                difference(){
                        union(){
                                translate([1,r*1.5,0]){
                                        rotate([90,0,90])
                                                schnecke(modul, gangzahl, laenge, bohrung, eingriffswinkel, steigungswinkel, zusammen_gebaut=true);
                                }
                                translate([laenge+1,-r*1.5,0]){
                                        rotate([90,0,-90])
                                                schnecke(modul, gangzahl, laenge, bohrung, eingriffswinkel, steigungswinkel, zusammen_gebaut=true);
                                        }
                                }
                        translate([laenge/2+1,0,-(r+modul+1)/2]){
                                        cube([laenge+2,3*r+2*(r+modul+1),r+modul+1], center = true);
                                }
                }
        }
}

/*
Berechnet einen Schneckenradsatz. Das Schneckenrad ist ein gewoehnliches Stirnrad ohne Globoidgeometrie.
modul = Hoehe des Schneckenkopfes ueber dem Teilzylinder bzw. des Zahnkopfes ueber dem Teilkreis
zahnzahl = Anzahl der Radzaehne
gangzahl = Anzahl der Gaenge (Zaehne) der Schnecke
breite = Zahnbreite
laenge = Laenge der Schnecke
bohrung_schnecke = Durchmesser der Mittelbohrung der Schnecke
bohrung_rad = Durchmesser der Mittelbohrung des Stirnrads
eingriffswinkel = Eingriffswinkel, Standardwert = 20° gemaess DIN 867. Sollte nicht groesser als 45° sein.
steigungswinkel = Steigungswinkel der Schnecke, entspricht 90°-Schraegungswinkel. Positiver Steigungswinkel = rechtsdrehend.
optimiert = Loecher zur Material-/Gewichtsersparnis
zusammen_gebaut =  Komponenten zusammengebaut fuer Konstruktion oder auseinander zum 3D-Druck */
module schneckenradsatz(modul, zahnzahl, gangzahl, breite, laenge, bohrung_schnecke, bohrung_rad, nabendurchmesser, nabendicke, eingriffswinkel=20, steigungswinkel, optimiert=true, zusammen_gebaut=true){

        c = modul / 6;                                                                                                // Kopfspiel
        r_schnecke = modul*gangzahl/(2*sin(steigungswinkel));                // Teilzylinder-Radius Schnecke
        r_rad = modul*zahnzahl/2;                                                                        // Teilkegelradius Stirnrad
        rf_schnecke = r_schnecke - modul - c;                                                // Fusszylinder-Radius
        gamma = -90*breite*sin(steigungswinkel)/(pi*r_rad);                        // Rotationswinkel Stirnrad
        zahnabstand = modul*pi/cos(steigungswinkel);                                // Zahnabstand im Transversalschnitt
        x = istgerade(gangzahl)? 0.5 : 1;

        if (zusammen_gebaut) {
                translate([r_schnecke,(ceil(laenge/(2*zahnabstand))-x)*zahnabstand,0])
                        rotate([90,180/gangzahl,0])
                                schnecke(modul, gangzahl, laenge, bohrung_schnecke, eingriffswinkel, steigungswinkel, zusammen_gebaut);

                translate([-r_rad,0,-breite/2])
                        rotate([0,0,gamma])
                                stirnrad (modul, zahnzahl, breite, bohrung_rad, nabendicke, nabendurchmesser, eingriffswinkel, -steigungswinkel, optimiert);
        }
        else {
                schnecke(modul, gangzahl, laenge, bohrung_schnecke, eingriffswinkel, steigungswinkel, zusammen_gebaut);

                translate([-2*r_rad,0,0])
                        stirnrad (modul, zahnzahl, breite, bohrung_rad, nabendicke, nabendurchmesser, eingriffswinkel, -steigungswinkel, optimiert);
        }
}



if(Gear_type == "1") {
    zahnstange(modul=Module, laenge=rack_length, hoehe=rack_height, breite=width, eingriffswinkel=pressure_angle, schraegungswinkel=finalHelixAngle);
}

else if(Gear_type == "2" ) {
    stirnrad (modul=Module, zahnzahl=teeth, breite=width, bohrung=bore, nabendurchmesser=final_hub_diameter, nabendicke=final_hub_thickness, eingriffswinkel=pressure_angle, schraegungswinkel=finalHelixAngle, optimiert=optimized);


} else if(Gear_type == "3" ) {
    pfeilrad (modul=Module, zahnzahl=teeth, breite=width, bohrung=bore, nabendicke=final_hub_thickness, nabendurchmesser=final_hub_diameter, eingriffswinkel=pressure_angle, schraegungswinkel=finalHelixAngle, optimiert=optimized);


} else if(Gear_type == "4" ) {
    zahnstange_und_rad (modul=Module, laenge_stange=rack_length, zahnzahl_rad=teeth, hoehe_stange=rack_height, bohrung_rad=bore, breite=width, nabendicke=final_hub_thickness, nabendurchmesser=final_hub_diameter, eingriffswinkel=pressure_angle, schraegungswinkel=finalHelixAngle, zusammen_gebaut=assembled, optimiert=optimized);


} else if(Gear_type == "5" || Gear_type == "internal_spur_gear") {
    hohlrad (modul=Module, zahnzahl=teeth, breite=width, randbreite=rim_width, eingriffswinkel=pressure_angle, schraegungswinkel=finalHelixAngle);


} else if(Gear_type == "6" || Gear_type == "internal_herringbone_gear" ) {
    pfeilhohlrad (modul=Module, zahnzahl=teeth, breite=width, randbreite=rim_width, eingriffswinkel=pressure_angle, schraegungswinkel=finalHelixAngle);


} else if(Gear_type == "7" ) {
    planetengetriebe(modul=Module, zahnzahl_sonne=solar_teeth, zahnzahl_planet=planet_teeth, anzahl_planeten=number_of_planets, breite=width, randbreite=rim_width, bohrung=bore, eingriffswinkel=pressure_angle, schraegungswinkel=finalHelixAngle, zusammen_gebaut=assembled, optimiert=optimized);


} else if(Gear_type == "8" ) {
    kegelrad(modul=Module, zahnzahl=teeth,  teilkegelwinkel=bevel_angle, zahnbreite=bevel_width, bohrung=bore, eingriffswinkel=pressure_angle, schraegungswinkel=finalHelixAngle);
} else if(Gear_type == "herringbone_bevel_gear" ) {
    pfeilkegelrad(modul=Module, zahnzahl=teeth, teilkegelwinkel=bevel_angle, zahnbreite=bevel_width, bohrung=bore, eingriffswinkel=pressure_angle, schraegungswinkel=finalHelixAngle);


} else if(Gear_type == "9" ) {
    kegelradpaar(modul=Module, zahnzahl_rad=idler_teeth, zahnzahl_ritzel=teeth, achsenwinkel=shaft_angle, zahnbreite=bevel_width, bohrung_rad=idler_bore, bohrung_ritzel=bore, eingriffswinkel=pressure_angle, schraegungswinkel=finalHelixAngle, zusammen_gebaut=assembled);


} else if(Gear_type == "10" ) {
    pfeilkegelradpaar(modul=Module, zahnzahl_rad=idler_teeth, zahnzahl_ritzel=teeth, achsenwinkel=shaft_angle, zahnbreite=bevel_width, bohrung_rad=idler_bore, bohrung_ritzel=bore, eingriffswinkel=pressure_angle, schraegungswinkel=finalHelixAngle, zusammen_gebaut=assembled);


} else if(Gear_type == "11" ) {
    schnecke(modul=Module, gangzahl=worm_starts, laenge=worm_length, bohrung=worm_bore, eingriffswinkel=pressure_angle, steigungswinkel=lead_angle, zusammen_gebaut=assembled);


} else if(Gear_type == "12" ) {
    schneckenradsatz(modul=Module, zahnzahl=teeth, gangzahl=worm_starts, breite=width, laenge=worm_length, bohrung_schnecke=worm_bore, bohrung_rad=bore, nabendicke=final_hub_thickness, nabendurchmesser=final_hub_diameter, eingriffswinkel=pressure_angle, steigungswinkel=lead_angle, optimiert=optimized, zusammen_gebaut=assembled);
}

RAW code

Planetengetriebe 3

nach oben