Schlauchpumpe

Dieses Projekt beschreibt eine parametrierbare Schlauchpumpe. Das 3D-Objekt wird mit OpenSCAD erstellt.
Eine Schlauchpumpe, auch Rollenpumpe oder Peristaltikpumpe genannt, ist eine Verdrängerpumpe, bei der das zu fördernde Medium durch äußere, mechanische Verformung eines Schlauches durch diesen hindurchgedrückt wird. Sie ist entsprechend ihrer Arbeitsweise den Rotationskolbenpumpen zuzuordnen und gehört aufgrund ihrer Bauart zu den Umlaufkolbenpumpen.
Die Schlauchpumpe

Mit einem 3D-Druck Projekt konstruieren wir eine Schlauchpumpe. Die STL-Dateien werden in OpenSCAD erstellt.
OpenSCAD Programm

Schlauchpumpe


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

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

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

// keine

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

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

// keine

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

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

// Abstand zwischen den Zahnrädern:
tol=0.15;

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


// --------  Angaben zu den verwendeten Schläuchen,
//in mm------------

// Außendurchmesser des Rohres in mm
tubing_od = 4.7625;

// Wandstärke desSchlauches
tubing_wall_thickness = 0.79375;
// Menge, die von den Walzen komprimiert werden soll, im Verhältnis zur Gesamtdicke (0 = kein Quetschen, 1,0 = vollständiges Quetschen)
tubing_squish_ratio = 0.5;


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

// Ungefährer Außendurchmesser des Rings in mm
D=51.7;

// Dicke, d.h. Höhe in mm
T=15;

// Anzahl der Planetengetriebe
number_of_planets=3;

// Anzahl der Zähne auf Planetengetrieben
number_of_teeth_on_planets=7;

// Anzahl der Zähne auf Sonnenschutzgeräten (ungefähr)
approximate_number_of_teeth_on_sun=9;

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

// Anzahl der Zähne
nTwist=1;

// Breite des sechseckigen Lochs
w=6.7;

DR=0.5*1;// maximales Tiefenverhältnis der Zähne
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));

// temporäre Variablen zur Berechnung des äußeren Radius der äußeren Ringzahnräder
// Wird verwendet, um die Freigabe für 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;

// temporäre Variablen zur Berechnung des äußeren Radius der Planetenzahnräder
// 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;

// temporäre Variablen zur Berechnung des Innen- und Außenradius der Sonnenzahnräder
// Wird verwendet, um die Freigabe für 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])
{
        // Äußerer 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);
                                // Lücke für Planetenquetschfläche
                                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 Zahnräder

        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))
];
RAW code