/*
*******************************************
Objekt Info: Parametrierbare Schlauchpumpe

*******************************************
Version: 07.08.2022 khf
*******************************************
*/

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

// keine

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

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

// keine

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

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

// Abstand zwischen den Zahnraedern:
tol=0.15;

// ueberhang zwischen 0 und 0,999 (0 = keine, 0,5 = 45 Grad, 1 = unendlich)
allowed_overhang = 0.75;


// --------  Angaben zu den verwendeten Schlaeuchen,
//in mm------------

// Aussendurchmesser des Rohres in mm
tubing_od = 4.7625;

// Wandstaerke desschlauches
tubing_wall_thickness = 0.79375;
// Menge, die von den Walzen komprimiert werden soll, im Verhaeltnis zur Gesamtdicke (0 = kein Quetschen, 1,0 = vollstaendiges Quetschen)
tubing_squish_ratio = 0.5;


// -------- Einstellung der Teilegeometrie ------------

// Ungefaehrer Aussendurchmesser des Rings in mm
D=51.7;

// Dicke, d.h. Hoehe in mm
T=15;

// Anzahl der Planetengetriebe
number_of_planets=3;

// Anzahl der Zaehne auf Planetengetrieben
number_of_teeth_on_planets=7;

// Anzahl der Zaehne auf Sonnenschutzgeraeten (ungefaehr)
approximate_number_of_teeth_on_sun=9;

// Druckwinkel
P=45;//[30:60]

// Anzahl der Zaehne
nTwist=1;

// Breite des sechseckigen Lochs
w=6.7;

DR=0.5*1;// maximales Tiefenverhaeltnis der Zaehne
len=100;
//*****************************************

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

m=round(number_of_planets);
np=round(number_of_teeth_on_planets);
ns1=approximate_number_of_teeth_on_sun;
k1=round(2/m*(ns1+np));
k= k1*m%2!=0 ? k1+1 : k1;
ns=k*m/2-np;
echo(ns);
nr=ns+2*np;
pitchD=0.9*D/(1+min(PI/(2*nr*tan(P)),PI*DR/nr));
pitch=pitchD*PI/nr;
echo(pitch);
helix_angle=atan(2*nTwist*pitch/T);
echo(helix_angle);

phi=$t*360/m;

// Berechnen der Schlauch-Parameter
tubing_squished_width = tubing_od * (PI/2);
tubing_depth_clearance = 2*(tubing_wall_thickness*(1-tubing_squish_ratio));

// temporaere Variablen zur Berechnung des aeusseren Radius der aeusseren Ringzahnraeder
// Wird verwendet, um die Freigabe fuer die peristaltische Squeezer-Funktion auf den Planeten zu machen
outerring_pitch_radius = nr*pitch/(2*PI);
outerring_depth=pitch/(2*tan(P));
outerring_outer_radius = tol<0 ? outerring_pitch_radius+outerring_depth/2-tol : outerring_pitch_radius+outerring_depth/2;

// temporaere Variablen zur Berechnung des aeusseren Radius der Planetenzahnraeder
// Wird verwendet, um die peristaltische Squeezer-Funktion auf den Planeten zu machen
planet_pitch_radius = np*pitch/(2*PI);
planet_depth=pitch/(2*tan(P));
planet_outer_radius = tol<0 ? planet_pitch_radius+planet_depth/2-tol : planet_pitch_radius+planet_depth/2;

// temporaere Variablen zur Berechnung des Innen- und Aussenradius der Sonnenzahnraeder
// Wird verwendet, um die Freigabe fuer Planetenquetscher zu machen
sun_pitch_radius = ns*pitch/(2*PI);
sun_base_radius = sun_pitch_radius*cos(P);
echo(sun_base_radius);
sun_depth=pitch/(2*tan(P));
sun_outer_radius = tol<0 ? sun_pitch_radius+sun_depth/2-tol : sun_pitch_radius+sun_depth/2;
sun_root_radius1 = sun_pitch_radius-sun_depth/2-tol/2;
sun_root_radius = (tol<0 && sun_root_radius1<sun_base_radius) ? sun_base_radius : sun_root_radius1;
sun_min_radius = max (sun_base_radius,sun_root_radius);


//translate([0,0,5])
//{
//        //halftooth (pitch_angle=5,base_radius=1, min_radius=0.1,        outer_radius=5,        half_thick_angle=3);
//        gear2D(number_of_teeth=number_of_teeth_on_planets, circular_pitch=pitch, pressure_angle=P, depth_ratio=DR, clearance=tol);
//}

translate([0,0,T/2])
{
        // aeusserer Ring
        difference()
        {

                cylinder(r=D/2 + tubing_depth_clearance,h=T,center=true,$fn=100);
                exitholes(outerring_outer_radius-tubing_od/4,tubing_od);
                union()
                {
                        herringbone(nr,pitch,P,DR,-2*tol,helix_angle,T+0.2);
                        cylinder(r=outerring_outer_radius+tubing_depth_clearance,h=tubing_squished_width,center=true,$fn=100);

                        // Zahnradwurzeldurchmesser
                        translate([0, 0, tubing_squished_width/2])
                        {
                                cylinder(r1=outerring_outer_radius+tubing_depth_clearance, r2=outerring_depth,h=abs(outerring_outer_radius+tubing_depth_clearance - outerring_depth)/tan(allowed_overhang*90),center=false,$fn=100);
                        }
                }
        }



        // Sonnenrad
        rotate([0,0,(np+1)*180/ns+phi*(ns+np)*2/ns])

        difference()
        {


                difference()
                {
                        mirror([0,1,0])
                                herringbone(ns,pitch,P,DR,tol,helix_angle,T);
                                // Zentrierbohrung
                                cylinder(r=w/sqrt(3),h=T+1,center=true,$fn=6);
                                // Luecke fuer Planetenquetschflaeche
                                difference()
                                {
                                        cylinder(r=sun_outer_radius,h=tubing_squished_width,center=true,$fn=100);
                                        cylinder(r=sun_min_radius-tol,h=tubing_squished_width,center=true,$fn=100);
                                }
                }

                //
                translate([0, 0, tubing_squished_width/2])
                {
                        difference()
                        {

                                cylinder(r=sun_outer_radius,h=abs((sun_min_radius-tol)-sun_outer_radius)/tan(allowed_overhang*90),center=false,$fn=100);
                                cylinder(r1=sun_min_radius-tol, r2=sun_outer_radius,h=abs((sun_min_radius-tol)-sun_outer_radius)/tan(allowed_overhang*90),center=false,$fn=100);
                        }
                }

        }



        // Planet Zahnraeder

        for(i=[1:m])
        {

                rotate([0,0,i*360/m+phi])
                {

                        translate([pitchD/2*(ns+np)/nr,0,0])
                        {
                                rotate([0,0,i*ns/m*360/np-phi*(ns+np)/np-phi])
                                {
                                        union()
                                        {
                                                herringbone(np,pitch,P,DR,tol,helix_angle,T);

                                                intersection()
                                                {
                                                        // der Zylinder
                                                        cylinder(r=planet_outer_radius,h=tubing_squished_width-tol,center=true,$fn=100);


                                                        planet_overhangfix(np, pitch, P, DR, tol, helix_angle, T, tubing_squished_width, allowed_overhang);

                                                }

                                        }

                                }
                        }
                }
        }

}


module planet_overhangfix(
        number_of_teeth=15,
        circular_pitch=10,
        pressure_angle=28,
        depth_ratio=1,
        clearance=0,
        helix_angle=0,
        gear_thickness=5,
        tubing_squished_width,
        allowed_overhang)
{

        height_from_bottom =  (gear_thickness/2) - (tubing_squished_width/2);
        pitch_radius = number_of_teeth*circular_pitch/(2*PI);
        twist=tan(helix_angle)*height_from_bottom/pitch_radius*180/PI; // the total rotation angle at that point - should match that of the gear itself



        translate([0,0, -tubing_squished_width/2])

        {

                rotate([0, 0, twist])
                {
                        linear_extrude(height=tubing_squished_width-clearance,twist=0,slices=6, scale=1+(1/(1-allowed_overhang)))
                        {
                                gear2D(number_of_teeth=number_of_teeth, circular_pitch=circular_pitch, pressure_angle=pressure_angle, depth_ratio=depth_ratio, clearance=clearance);
                        }
                }
        }
}

module exitholes(distance_apart, hole_diameter)
{
        translate([distance_apart, len/2, 0])
        {
                rotate([90, 0, 0])
                {
                        cylinder(r=hole_diameter/2,h=len,center=true,$fn=100);
                }
        }

        mirror([1,0,0])
        {
                translate([distance_apart, len/2, 0])
                {
                        rotate([90, 0, 0])
                        {
                                cylinder(r=hole_diameter/2,h=len,center=true,$fn=100);
                        }
                }
        }
}

module rack(
        number_of_teeth=15,
        circular_pitch=10,
        pressure_angle=28,
        helix_angle=0,
        clearance=0,
        gear_thickness=5,
        flat=false){
addendum=circular_pitch/(4*tan(pressure_angle));

flat_extrude(h=gear_thickness,flat=flat)translate([0,-clearance*cos(pressure_angle)/2])
        union(){
                translate([0,-0.5-addendum])square([number_of_teeth*circular_pitch,1],center=true);
                for(i=[1:number_of_teeth])
                        translate([circular_pitch*(i-number_of_teeth/2-0.5),0])
                        polygon(points=[[-circular_pitch/2,-addendum],[circular_pitch/2,-addendum],[0,addendum]]);
        }
}



module herringbone(
        number_of_teeth=15,
        circular_pitch=10,
        pressure_angle=28,
        depth_ratio=1,
        clearance=0,
        helix_angle=0,
        gear_thickness=5){
union(){
        //translate([0,0,10])
        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*PI);
twist=tan(helix_angle)*gear_thickness/pitch_radius*180/PI;

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=twist/6, scale=1)child(0);
        else
                child(0);
}

module gear2D (
        number_of_teeth,
        circular_pitch,
        pressure_angle,
        depth_ratio,
        clearance){
pitch_radius = number_of_teeth*circular_pitch/(2*PI);
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 / PI;
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=[0,1,2,3,4,5];
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=[[0,0],
        involute(base_radius,angle[0]+start_angle),
        involute(base_radius,angle[1]+start_angle),
        involute(base_radius,angle[2]+start_angle),
        involute(base_radius,angle[3]+start_angle),
        involute(base_radius,angle[4]+start_angle),
        involute(base_radius,angle[5]+start_angle)];

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

// Mathematische Funktionen

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

function involute (base_radius, involute_angle) =
[
        base_radius*(cos (involute_angle) + involute_angle*PI/180*sin (involute_angle)),
        base_radius*(sin (involute_angle) - involute_angle*PI/180*cos (involute_angle))
];