Der Drehknopf

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

OpenSCAD Programm

Drehknopf

/*
*******************************************
Objekt Info: Poti Drehknopf

*******************************************
Version: 15.01.2023 khf
*******************************************
*/

//***************   Auswahl   *************
// Form der Oberseite des Knopfes.  Der Typ "Einbau" kann lackiert werden.
CapType = 1;        // [0:Flach, 1:Einbau, 2:Dome]

// Moechtest du einen grossen StilZeiger?
TimerKnob=0;        // [0:Nein, 1:Ja]

// Moechtest du eine Markierung oben, um die Richtung anzuzeigen?
Pointer1 = 1;        // [0:Nein, 1:Ja]

// Moechtest du einen Richtungszeiger?
Pointer2 = 0;        // [0:Nein, 1:Ja]

// Willst du einen Raendelung um den Knopf?
Knurled = 1;        // [0:Nein, 1:Ja]

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

//keine

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

//***************  Parameter   *************
$fn=60;

// Loch-Durchmesser in mm.
HoleDiameter = 6;

// Tiefe des Lochs im Boden (in mm).
HoleDepth = 10;

// Wenn du ein D-foermiges Loch wuenscht, stelle die Dicke auf der flachen Seite (in mm) ein.  Groessere Werte fuer die Ebene machen das Loch kleiner.
HoleFlatThickness = 1;

// Hoehe (in mm).  Wenn die Kuppelkappe ausgewaehlt ist, ist sie nicht in der Hoehe enthalten.  Auch die Wellenlaenge wird nicht gezaehlt.
KnobHeight = 20;

// Durchmesser des Knopfes in mm.
KnobDiameter = 15;

// 0 = Verjuengung
TaperPercentage = 20;                // [0:0%, 10:10%, 20:20%, 30:30%, 40:40%, 50:50%]

// Breite des Rings "Dial" (in mm).  0= keine RIng
RingWidth = 2;

// Die Anzahl der Markierungen auf dem Zifferblatt.  0 = keine Markierungen   (RingWidth muss ungleich Null sein.)
RingMarkings = 1;

// Durchmesser des Lochs fuer die Befestigungsschraube in mm.  0 = kein Loch
ScrewHoleDiameter = 2;

//  Laenge der Welle auf der Unterseite des Knopfes (in mm).  0 = keine Welle
ShaftLength = 0;

// Durchmesser der Welle auf der Unterseite des Knopfes in mm.  (ShaftLength groesser Null sein.)
ShaftDiameter = 10;

// Moechtest du eine Kerbe in der Welle?  Es kann fuer einen Einpressknopf verwendet werden (anstelle einer Befestigungsschraube).  (ShaftLength groesser Null sein.)
NotchedShaft = 0;        // [0:No, 1:Yes]


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

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





//////////////////////////
//Erweiterte Einstellungen
//////////////////////////

RingThickness = 5*1;
DivotDepth = 1.5*1;
MarkingWidth = 1.5*1;
DistanceBetweenKnurls = 3*1;
TimerKnobConst = 1.8*1;



//////////////////////////
//Berechnungen
//////////////////////////

PI=3.14159265*1;
KnobMajorRadius = KnobDiameter/2;
KnobMinorRadius = KnobDiameter/2 * (1 - TaperPercentage/100);
KnobRadius = KnobMinorRadius + (KnobMajorRadius-KnobMinorRadius)/2;
KnobCircumference = PI*KnobDiameter;
Knurls = round(KnobCircumference/DistanceBetweenKnurls);
Divot=CapType;

TaperAngle=asin(KnobHeight / (sqrt(pow(KnobHeight, 2) +
                pow(KnobMajorRadius-KnobMinorRadius,2)))) - 90;

DivotRadius = KnobMinorRadius*.4;


union()
{
translate([0, 0, (ShaftLength==0)? 0 : ShaftLength-0.001])
difference()
{
union()
{
        // Primary knob cylinder
        cylinder(h=KnobHeight, r1=KnobMajorRadius, r2=KnobMinorRadius,
                        $fn=50);

        if (Knurled)
                for (i=[0 : Knurls-1])
                        rotate([0, 0, i * (360/Knurls)])
                                translate([KnobRadius, 0, KnobHeight/2])
                                        rotate([0, TaperAngle, 0]) rotate([0, 0, 45])
                                                cube([2, 2, KnobHeight+.001], center=true);

         if (RingMarkings>0)
                for (i=[0 : RingMarkings-1])
                        rotate([0, 0, i * (360/RingMarkings)])
                                translate([KnobMajorRadius + RingWidth/2, 0, 1])
                                        cube([RingWidth*.5, MarkingWidth, 2], center=true);

        if (Pointer2==1)
                translate([KnobRadius, 0, KnobHeight/2-2])
                        rotate([0, TaperAngle, 0])
                                cube([8, 3, KnobHeight], center=true);

        if (RingWidth>0)
                translate([0, 0, RingThickness/2])
                        cylinder(r1=KnobMajorRadius + RingWidth, r2=KnobMinorRadius,
                                        h=RingThickness, $fn=50, center=true);

        if (Divot==2)
                translate([0, 0, KnobHeight])
                        difference()
                        {
                                scale([1, 1, 0.5])
                                        sphere(r=KnobMinorRadius, $fn=50, center=true);

                                translate([0, 0, 0-(KnobMinorRadius+.001)])
                                        cube([KnobMinorRadius*2.5, KnobMinorRadius*2.5,
                                                        KnobMinorRadius*2], center=true);
                        }

        if (TimerKnob==1) intersection()
                {
                        translate([0, 0, 0-(KnobDiameter*TimerKnobConst) + KnobHeight])
                        sphere(r=KnobDiameter*TimerKnobConst, $fn=80, center=true);

                        translate([0-(KnobDiameter*TimerKnobConst)*0.1, 0,
                                        KnobHeight/2])
                                scale([1, 0.5, 1])
                                        cylinder(h=KnobHeight, r=(KnobDiameter*TimerKnobConst) *
                                                        0.8, $fn=3, center=true);
                }
}

// Zeiger1
if (Pointer1==1)
        translate([KnobMinorRadius*.55, 0, KnobHeight + DivotRadius*.6])
                sphere(r=DivotRadius, $fn=40);

// Divot1: Zentrierter zylynischer Divot
if (Divot==1)
        translate([0, 0, KnobHeight])
                cylinder(h=DivotDepth*2, r=KnobMinorRadius-1.5, $fn=50,
                                center=true);

if (ShaftLength==0)
{
        // Loch fuer Welle
        translate([0, 0, HoleDepth/2 - 0.001])
                difference()
                {
                        cylinder(r=HoleDiameter/2, h=HoleDepth, $fn=20,
                                        center=true);

                        // D-foermiges Loch
                        translate([(0-HoleDiameter)+HoleFlatThickness, 0, 0])
                                cube([HoleDiameter, HoleDiameter, HoleDepth+.001],
                                                center=true);
                }

        // Loch fuer Befestigungsschraube
        if (ScrewHoleDiameter>0)
                translate([0 - (KnobMajorRadius+RingWidth+1)/2, 0,
                                HoleDepth/2])
                        rotate([0, 90, 0])
                        cylinder(h=(KnobMajorRadius+RingWidth+1),
                                        r=ScrewHoleDiameter/2, $fn=20, center=true);
}

// Stelle sicher, dass die unteren Enden bei z=0
translate([0, 0, -10])
        cube([(KnobMajorRadius+RingWidth) * 3,
                        (KnobMajorRadius+RingWidth) * 3, 20], center=true);
}

if (ShaftLength>0)
        difference()
        {
                translate([0, 0, ShaftLength/2])
                        cylinder(h=ShaftLength, r=ShaftDiameter/2, $fn=20,
                                        center=true);

                if (NotchedShaft==1)
                {
                        cube([HoleDiameter/2, ShaftDiameter*2, ShaftLength],
                                        center=true);
                }

                // Loch fuer Welle
                translate([0, 0, HoleDepth/2 - 0.001])
                        difference()
                        {
                                cylinder(r=HoleDiameter/2, h=HoleDepth, $fn=20,
                                                center=true);

                                // D-foermiges Loch
                                translate([(0-HoleDiameter)+HoleFlatThickness, 0, 0])
                                        cube([HoleDiameter, HoleDiameter, HoleDepth+.001],
                                                        center=true);
                        }

                // Loch fuer Befestigungsschraube
                if (ScrewHoleDiameter>0)
                        translate([0 - (KnobMajorRadius+RingWidth+1)/2, 0,
                                        HoleDepth/2])
                                rotate([0, 90, 0])
                                cylinder(h=(KnobMajorRadius+RingWidth+1),
                                                r=ScrewHoleDiameter/2, $fn=20, center=true);
        }
}

RAW code

nach oben