3D Konstruktion mit OpenSCAD – Der Servo- Halter

Nun geht es endlich richtig los. Wir konstruieren unseren parametrierbaren Servo- Halter. Als Ausgangsbasis verwenden wir die im letzten Kapitel konstruierte Grundplatte.

difference() {
cube([65,30,3]);
translate([4,4,-1])cylinder(h=5, d=3.2, $fn = 300);
translate([4,26,-1])cylinder(h=5, d=3.2, $fn = 300);
translate([61,4,-1])cylinder(h=5, d=3.2, $fn = 300);
translate([61,26,-1])cylinder(h=5, d=3.2, $fn = 300);
}

Allerdings wollen wir unsere Konstruktion ja flexibel für alle möglichen Servos einsetzen können. Deswegen müssen wir die tatsächlichen Abmessungen als Variablen und nicht als feste Werte verwenden. Also müssen wir zunächst mal bestimmen, wie viele Variablen wir benötigen und vom tatsächlichen Servo abnehmen müssen, und was wir im Skript errechnen können. OpenSCAD kann einige mathematische Operationen durchführen, die uns dabei helfen werden. Je weniger Maße wir tatsächlich eingeben müssen, desto leichter und schneller ist der Halter anpassbar. Wenn wir uns hierbei vertun und ein Maß vergessen oder eines zu viel anlegen, macht das nichts. Man kann Variablen jederzeit hinzufügen oder entfernen.

Da wir jetzt etwas “für die Ewigkeit” konstruieren, sollten wir unser Projekt natürlich auch speichern, um es später weiter bearbeiten oder verwenden zu können. Beim ersten Mal nutzen wir dazu “Speichern unter”, um einen Pfad und Dateinamen festlegen zu können. “Speichern unter” ist, wie bei fast allen Programmen im Menü oben links unter “Datei” zu finden.  Wie ihr das Projekt benennt, ist euch überlassen. Bei mir heißt es “Servo_Halter.scad” Der Namen spielt keine Rolle, sollte aber auf jeden Fall zum Wiederfinden geeignet sein. Die Dateiendung .scad ist allerdings Pflicht, damit OpenSCAD weiß, um was es sich handelt. Tatsächlich ist die .scad Datei eine reine Text Datei, die man in jedem Editor öffnen und anschauen kann. Darin steht genau das, was wir in den Editor von OpenSCAD getippt haben. Nicht mehr und nicht weniger. Sobald wir das Projekt gespeichert haben, steht oben in der Überschrift nicht mehr “Unbekannt”, sondern der Name, den wir unserer Datei gegeben haben.

Ich habe auch schon zusätzliche Kommentare sowie den Platz für die Variablen- Deklaration eingefügt. Man kann schon jetzt erkennen, das die Kommentare helfen, das Skript zu ordnen und übersichtlicher zu machen… Auch Leerzeilen kann und sollte man dazu einsetzen. Je sauberer man hier ist, desto leichter fällt einem in Monaten oder Jahren, durch das Script durchzublicken und zu verstehen, was man damals gemacht hat…

Welche Maße benötigen wir nun aber? Zunächst mal die Breite des Servos, die Höhe des Servos, aber ohne die Ausbuchtung für den Antrieb des Steuerhorns. Natürlich benötigen wir auch die Länge des Servos. Das messen wir aber ohne die Befestigungsflansche, dafür mit ca 1 mm Zugabe, um etwas Spielraum zu bekommen. Das reicht aber noch nicht. Wir brauchen daneben auch die Länge eines Befestigungsflansches sowie den Abstand zwischen der Unterseite des Flansches und der Oberseite des Servos (wieder ohne die Erhebungen für den Ruderhorn- Antrieb).  Den Abstand zwischen den Befestigungslöchern benötigen wir auch noch. Wenn man den Halter für Mikro- Servos einsetzen will, die nur ein Befestigungsloch pro Seite haben, dann müssen wir den Abstand auf 0 setzen. Wenn ich richtig gezählt habe, sind das sechs Variablen, die wir nun deklarieren, also festlegen müssen.

Die Werte, die ich hier verwende passen für “meine” Modelcraft RS-2 Servos. Bei euch sind höchstwahrscheinlich andere Werte zu verwenden. Genau darum machen wir das mit den Variablen ja..

// OpenSCAD Tutorial Servo- Halter

// Variablendeklaration
$la = 42; //Länge des Servo + 1 mm Spielraum
$br = 20; //Breite des Servo
$ho = 35; //Höhe des Servo
$bf = 8; //Länge des Flansch
$bfh = 11; // Höhe des Flansch
$lo = 10; //Lochabstand

// Grundplatte
difference() {
cube([65,30,3]);
translate([4,4,-1])cylinder(h=5, d=3.2, $fn = 300);
translate([4,26,-1])cylinder(h=5, d=3.2, $fn = 300);
translate([61,4,-1])cylinder(h=5, d=3.2, $fn = 300);
translate([61,26,-1])cylinder(h=5, d=3.2, $fn = 300);
}

Wie man sieht, kann man auch mitten in einer Zeile mit einem Kommentar anfangen.  Hier wird das dazu verwendet, zu beschreiben, für was die gerade festgelegte Variable eigentlich steht. Wie ihr die Variablen benennt, ist euch überlassen. Man muss nur aufpassen, das der Variablenname nicht derselbe wird, wie eine OpenSCAD Funktion oder Systemvariable. Das merkt ihr aber schon, wenn das Skript nicht funktioniert… Nun sollten wir under Projekt erst mal wieder speichern. Es ist sinnvoll, alle paar Minuten zu speichern, damit bei einem Absturz oder ähnlichem nicht die ganze Arbeit zum Teufel ist. Da wir bereits einen Namen und Pfad vergeben haben, können wir nun einfach “Speichern” im Datei- Menü dazu verwenden. Wer lieber mit Tastaturkürzeln arbeitet, Speichern ist wie in sehr, sehr vielen anderen Programmen auch STRG und S…

Jetzt haben wir unsere Variablen festgelegt. Wie gesagt, wenn das noch nicht passt, man also was vergessen hat, kann man jederzeit weitere Variablen hinzufügen.

Weil wir gerade dabei sind, ich denke, es ist sinnvoll, auch die Dicke der Grundplatte einstellbar zu machen. Auf diese Art kann man bei Bedarf zusätzlichen Platz für ein Ruderhorn schaffen, welches in Richtung Grundplatte montiert werden soll/muss.. Also schnell noch eine Variable hinzugefügt:

// OpenSCAD Tutorial Servo- Halter

// Variablendeklaration
$la = 42; //Länge des Servo + 1 mm Spielraum
$br = 20; //Breite des Servo
$ho = 35; //Höhe des Servo
$bf = 8; //Länge des Flansch
$bfh = 11; // Höhe des Flansch
$lo = 10; //Lochabstand
$gd = 3; // Dicke der Grundplatte, nicht unter 2 mm

// Grundplatte
difference() {
cube([65,30,3]);
translate([4,4,-1])cylinder(h=5, d=3.2, $fn = 300);
translate([4,26,-1])cylinder(h=5, d=3.2, $fn = 300);
translate([61,4,-1])cylinder(h=5, d=3.2, $fn = 300);
translate([61,26,-1])cylinder(h=5, d=3.2, $fn = 300);
}

Ich denke, das reicht jetzt erst mal an Variablen…  Fangen wir also an, unsere Grundplatte  auf die Variablen umzustellen. Am einfachsten ist das bei der Dicke der Platte, da man dort keinerlei Berechnungen durchführen muss.

Das Ergebnis sieht nicht anders aus als vorher, was ja auch zu erwarten war. Um zu zeigen, wie die Werte für die Variablen das Objekt beeinflussen, legen wir mal 10 für $gd fest:

// OpenSCAD Tutorial Servo- Halter

// Variablendeklaration
$la = 42; //Länge des Servo + 1 mm Spielraum
$br = 20; //Breite des Servo
$ho = 35; //Höhe des Servo
$bf = 8; //Länge des Flansch
$bfh = 11; // Höhe des Flansch
$lo = 10; //Lochabstand
$gd = 10; // Dicke der Grundplatte, nicht unter 2 mm

// Grundplatte
difference() {
cube([65,30,$gd]);
translate([4,4,-1])cylinder(h=5, d=3.2, $fn = 300);
translate([4,26,-1])cylinder(h=5, d=3.2, $fn = 300);
translate([61,4,-1])cylinder(h=5, d=3.2, $fn = 300);
translate([61,26,-1])cylinder(h=5, d=3.2, $fn = 300);
}

Und voila:

Die Grundplatte ist nun 10 mm Dick. Dafür sind aber unsere Bohrlöcher verschwunden. Eigentlich sind sie noch da, doch sie sind nicht mehr lang genug, um vollständig durch die Grundplatte zu reichen… Würden wir ohne Variablen arbeiten, müssten wir jetzt also alle vier Zylinder manuell korrigieren. Wir müssten statt an einer Stelle oben im Skript, an 5 Stellen Anpassungen vornehmen… Schon an diesem Beispiel sieht man, das sich der Einsatz von Variablen lohnt. Als wir die Grundplatte zuerst erzeugt haben, haben wir die Länge der Zylinder um 2 mm größer gemacht, als die Dicke der Arbeitsplatte. Genau das machen wir jetzt auch wieder. Wir schreiben überall da, wo vorher h = 5 stand nun h = $gd + 2…

// OpenSCAD Tutorial Servo- Halter

// Variablendeklaration
$la = 42; //Länge des Servo + 1 mm Spielraum
$br = 20; //Breite des Servo
$ho = 35; //Höhe des Servo
$bf = 8; //Länge des Flansch
$bfh = 11; // Höhe des Flansch
$lo = 10; //Lochabstand
$gd = 10; // Dicke der Grundplatte, nicht unter 2 mm

// Grundplatte
difference() {
cube([65,30,$gd]);
translate([4,4,-1])cylinder(h=$gd + 2, d=3.2, $fn = 300);
translate([4,26,-1])cylinder(h=$gd + 2, d=3.2, $fn = 300);
translate([61,4,-1])cylinder(h=$gd + 2, d=3.2, $fn = 300);
translate([61,26,-1])cylinder(h=$gd + 2, d=3.2, $fn = 300);
}

und schon sind die Löcher wieder da.

Wenn wir in Zukunft die Dicke der Grundplatte ändern, passen sich die Löcher automatisch mit an.

Hiermit haben wir die Dicke der Grundplatte und die Schraublöcher parametrierbar gemacht. Nun müssen wir noch die anderen Abmessungen, also Länge und Breite anpassen. Die Höhe der Grundplatte soll der Höhe des Servos entsprechen. Also ersetzen wir die  30 durch $ho. Die Länge der Grundplatte setzt sich zusammen aus der Länge des Servo $la, zweimal der Länge des Flansches $bf sowie 2 mm Spielraum zusätzlich. Also $la +$bf + $bf + 2. Das fügen wir nun statt der 65 bei der Definition des Kubus ein.

// OpenSCAD Tutorial Servo- Halter

// Variablendeklaration
$la = 42; //Länge des Servo + 1 mm Spielraum
$br = 20; //Breite des Servo
$ho = 35; //Höhe des Servo
$bf = 8; //Länge des Flansch
$bfh = 11; // Höhe des Flansch
$lo = 10; //Lochabstand
$gd = 3; // Dicke der Grundplatte, nicht unter 2 mm

// Grundplatte
difference() {
cube([$la +$bf + $bf + 2,$ho,$gd]);
translate([4,4,-1])cylinder(h=$gd + 2, d=3.2, $fn = 300);
translate([4,26,-1])cylinder(h=$gd + 2, d=3.2, $fn = 300);
translate([61,4,-1])cylinder(h=$gd + 2, d=3.2, $fn = 300);
translate([61,26,-1])cylinder(h=$gd + 2, d=3.2, $fn = 300);
}

Und, unser Ergebnis überzeugt wieder nicht wirklich:

Natürlich müssen wir auch die Position der Löcher an die Maße der Grundplatte anpassen. Das erste Loch sitzt noch passend. Das zweite Loch ist zu weit oben, da wir die Breite der Grundplatte nun größer gewählt haben. Statt 26 brauchen wir hier $ho – 4  Dieselbe “Formel” verwenden wir auch für das vierte Loch. Nun sitzen die Löcher in Y Richtung wieder passend. Loch 3 und 4 müssen aber noch in X Richtung angepasst werden, da unsere Grundplatte nun etwas kürzer ist. Zuvor haben wir 4 von der Länge der Grundplatte abgezogen. Das werden wir jetzt auch wieder tun. Also $la +$bf + $bf + 2 – 4.

// OpenSCAD Tutorial Servo- Halter

// Variablendeklaration
$la = 42; //Länge des Servo + 1 mm Spielraum
$br = 20; //Breite des Servo
$ho = 35; //Höhe des Servo
$bf = 8; //Länge des Flansch
$bfh = 11; // Höhe des Flansch
$lo = 10; //Lochabstand
$gd = 3; // Dicke der Grundplatte, nicht unter 2 mm

// Grundplatte
difference() {
cube([$la +$bf + $bf + 2,$ho,$gd]);
translate([4,4,-1])cylinder(h=$gd + 2, d=3.2, $fn = 300);
translate([4,$ho – 4,-1])cylinder(h=$gd + 2, d=3.2, $fn = 300);
translate([$la +$bf + $bf + 2 – 4,4,-1])cylinder(h=$gd + 2, d=3.2, $fn = 300);
translate([$la +$bf + $bf + 2 – 4,$ho – 4,-1])cylinder(h=$gd + 2, d=3.2, $fn = 300);
}

Ich lasse das mit +2 und – 4 bewusst erst mal stehen. Warum wird später aufgelöst.

Und nun passen die Löcher wieder.

Nun sind wir scheinbar wieder genau da, wo wir gestartet sind. Doch tatsächlich sind wir einen Riesensatz weiter. Wir können nun jede beliebig große Grundplatte mit passenden Löchern erzeugen, in dem wir nur ein paar wenige Abmessungen eingeben.

Nun noch die Auflösung, warum wir mit +2 – 4 hantiert haben. Inzwischen habe ich mir nämlich überlegt, das 3 mm Schrauben bei Mikro- Servos vielleicht etwas arg wuchtig sind. Deswegen möchte ich auch noch die Schraubenloch- Durchmesser und den dazu passenden Abstand vom Rand der Grundplatte einstellbar machen. Also definieren wir noch eine Variable, $dm, die den Schrauben- Durchmesser festlegt. Diesen Wert nutzen wir nun, um den Durchmesser der 4 Zylinder sowie den Abstand der Löcher vom Rand festzulegen. Der Durchmesser der Zylinder ist $dm + 0.2 und der Abstand wird $dm + 1.  Das muss jetzt schon an sehr vielen Stellen geändert werden. Ein manuelles Ändern der Löcher wäre nachträglich also ziemlich mühsam.

// OpenSCAD Tutorial Servo- Halter

// Variablendeklaration
$la = 42; //Länge des Servo + 1 mm Spielraum
$br = 20; //Breite des Servo
$ho = 35; //Höhe des Servo
$bf = 8; //Länge des Flansch
$bfh = 11; // Höhe des Flansch
$lo = 10; //Lochabstand
$gd = 3; // Dicke der Grundplatte, nicht unter 2 mm
$dm = 3 //Durchmesser der Befestigungsschrauben

// Grundplatte
difference() {
cube([$la +$bf + $bf + 2,$ho,$gd]);
translate([$dm + 1,$dm + 1,-1])cylinder(h=$gd + 2, d=$dm + 0.2, $fn = 300);
translate([$dm + 1,$ho – $dm + 1,-1])cylinder(h=$gd + 2, d=$dm + 0.2, $fn = 300);
translate([$la +$bf + $bf + 2 – $dm + 1,$dm + 1,-1])cylinder(h=$gd + 2, d=$dm + 0.2, $fn = 300);
translate([$la +$bf + $bf + 2 – $dm + 1,$ho – $dm + 1,-1])cylinder(h=$gd + 2, d=$dm + 0.2, $fn = 300);
}

Nun haben wir aber gleich alles an der Grundplatte parametrierbar gemacht.

Doch, wenn wir den Wert für $dm tatsächlich ändern, entsteht ein Fehler:

Wir haben hier Klammern vergessen, denn  2 – $dm + 1 ist nicht das, was wir eigentlich haben wollen. Da müssen wir schon 2 – ($dm + 1) schreiben. Ganz wie früher im Mathe- Unterricht. Ja, ich weiß, lang, lang ist’s her. Aber manchmal lohnt es sich in der hintersten Ecke des Gehirns herum zu graben…

// OpenSCAD Tutorial Servo- Halter

// Variablendeklaration
$la = 42; //Länge des Servo + 1 mm Spielraum
$br = 20; //Breite des Servo
$ho = 35; //Höhe des Servo
$bf = 8; //Länge des Flansch
$bfh = 11; // Höhe des Flansch
$lo = 10; //Lochabstand
$gd = 3; // Dicke der Grundplatte, nicht unter 2 mm
$dm = 1; //Durchmesser der Befestigungsschrauben

// Grundplatte
difference() {
cube([$la +$bf + $bf + 2,$ho,$gd]);
translate([$dm + 1,$dm + 1,-1])cylinder(h=$gd + 2, d=$dm + 0.2, $fn = 300);
translate([$dm + 1,$ho – ($dm + 1),-1])cylinder(h=$gd + 2, d=$dm + 0.2, $fn = 300);
translate([$la +$bf + $bf + 2 – ($dm + 1),$dm + 1,-1])cylinder(h=$gd + 2, d=$dm + 0.2, $fn = 300);
translate([$la +$bf + $bf + 2 – ($dm + 1),$ho – ($dm + 1),-1])cylinder(h=$gd + 2, d=$dm + 0.2, $fn = 300);
}

Jetzt funktioniert es endlich.

Ein schweres Stück Arbeit, oder?  Dafür sind wir jetzt schon fast fertig mit unserem Servo Halter. Wir brauchen nämlich nur noch 2 Kuben und 4 Zylinder, jeweils an den passenden Stellen und mit den passenden Abmessungen meint Parametern. Das war es dann auch schon (zumindest fast).

Um das Servo anschrauben zu können, benötigen wir zwei “Klötze”, die auf der Grundplatte befestigt sind. Das machen wir natürlich wieder mit einem Kubus. Der Kubus bekommt als X- Wert die Länge des Flansches + 1 (wir haben 2 mm bei der Grundplatte zugegeben, wisst ihr noch? Das war genau deswegen) also $bf + 1. In Z- Richtung bekommt der Kubus die Breite des Servos, also $br und in Y- Richtung können wir einen fixen Wert wählen.  Dieser Wert sollte nicht zu klein sein, damit das Ganze stabil genug wird, aber auch nicht zu lang, damit er nachher nicht über die Grundplatte raus ragt, wenn wir besonders kleine Servos verwenden. Ich werde es erst mal mit 10 probieren.  In den Kubus werden kleine selbst schneidende Schrauben eingedreht, für die wir Löcher vorbohren wollen. Das werden wir gleich mit erledigen. Dafür benötigen wir wieder die Zylinder. Die Löcher zur Befestigung in den Flanschen am Servo sind recht groß, da man speziell bei Einsatz von Verbrennungsmotoren in RC Modellen häufig starke Vibrationen hat. Deswegen werden dort normalerweise Gummitüllen eingefügt, die Vibrationen vom Servo fern halten.  Bei der Modellbahn treten solche Vibrationen aber nicht auf. Deswegen können wir die Servos einfach festschrauben. Da 5 mm Schrauben viel zu wuchtig wären, muss man eine Schraube mit Unterlegscheibe verwenden. Die eigentlich zu großen Löcher übernehmen dabei die Funktion von Langlöschern, die eine Feinjustage erlauben. Allerhöchste Genauigkeit ist also nicht erforderlich.

Fügen wir also erst mal einen Kubus ein. Die andere Seite machen wir später wieder mit “Kopieren und Einfügen”.

cube([$bf + 1,10,$br]);

Das sieht dann so aus:

Hier können wir nach der Syntax Hervorhebung eine weitere Komfort Funktion eines brauchbaren Editors sehen. (Notepad ist übrigens kein brauchbarer Editor)…  Komplexere Funktionen wie hier die “difference” Funktion können sich über viel Zeilen erstrecken. In den meisten Editoren gibt es deswegen diese kleinen – bzw. + Zeichen in den Quadraten.  Klickt man auf so ein Zeichen, wird der Bereich, der zu dieser komplexen Funktion gehört versteckt (bei Klick auf -) oder eingeblendet (bei Klick auf +). Das macht den Code deutlich übersichtlicher, weil man nur die Bereiche eingeblendet bekommt, an denen man gerade arbeitet. Unsere Grundplatte ist aber fertig. Da müssen wir nicht mehr ran. Also muss der viele Code auch nicht unbedingt angezeigt werden. Vorhanden ist er aber selbstverständlich weiterhin… Den Kubus an die passenden Position bringen, erledigen wir erst ganz am Ende. Zunächst erzeugen wir noch die Schraublöcher in dem Kubus. Dazu erzeugen wir einen Zylinder mit einem nicht zu großen Durchmesser, schließlich sollen die selbst schneidenden Schrauben ja Halt finden. Ich würde nicht mehr als maximal 1,5 mm Durchmesser wählen. Als Länge würde ich die Dicke des “Klotzes einstellen. Wenn wir dann wieder 1 mm “Luft” im oberen Bereich lassen, gehen die Löcher nicht ganz durch.

cylinder(h = 10, d = 1.5);

Den Zylinder müssen wir um -90 Grad in X Richtung rotieren.

rotate([-90,0,0])cylinder(h = 10, d = 1.5);

Jetzt müssen wir ihn noch an die passende Stelle bewegen.  In X Richtung muss er um die Hälfte der Kubusbreite verschoben werden, also ($bf + 1) / 2. Klammern nicht vergessen wegen Punkt vor Strich… In Y Richtung um -1. In Z Richtung sollten sich die beiden Löcher mit dem Lochabstand $lo mittig auf (eher in)  dem Kubus sitzen.  Der Wert ist also ($br – $lo) / 2

Also zusammen:

translate([($bf + 1) / 2, -1,(($br – $lo) / 2)])rotate([-90,0,0])cylinder(h = 10, d = 1.5);

Unser zweites Loch muss nun in Z Richtung um den Lochabstand $lo höher sitzen.

translate([($bf + 1) / 2, -1,(($br – $lo) / 2)] + $lo)rotate([-90,0,0])cylinder(h = 10, d = 1.5);

Die beiden Zylinder müssen wir nun natürlich vom Kubus abziehen, was nichts neues mehr ist.

difference(){
cube([$bf + 1,10,$br]);
translate([($bf + 1) / 2, -1,(($br – $lo) / 2)])rotate([-90,0,0])cylinder(h = 10, d = 1.5);
translate([($bf + 1) / 2, -1,(($br – $lo) / 2) + $lo])rotate([-90,0,0])cylinder(h = 10, d = 1.5);
}

Und wir haben zwei Löcher im “Befestigungsklötzchen”. Wenn $lo = 0 ist, weil es nur ein Loch gibt, liegen beide Zylinder genau in der Mitte exakt übereinander und ergeben so natürlich nur ein Loch. Also ist dieser Fall damit ebenfalls abgedeckt.

Nun müssen wir das ganze Gebilde noch an die passende Stelle bewegen. In Z Richtung muss es um die Dicke der Grundplatte verschoben werden. In Y Richtung um die Höhe des Flansches, $bfh. In X Richtung muss es gar nicht bewegt werden. Also alles zusammen:

//Seitenhalterung 1
translate([0,$bfh,$gd])difference(){
cube([$bf + 1,10,$br]);
translate([($bf + 1) / 2, -1,(($br – $lo) / 2)])rotate([-90,0,0])cylinder(h = 10, d = 1.5);
translate([($bf + 1) / 2, -1,(($br – $lo) / 2) + $lo])rotate([-90,0,0])cylinder(h = 10, d = 1.5);
}

Ergebnis:

Fast fertig. Es fehlt nur noch die zweite Seitenhalterung. Dazu kopieren wir den ganzen Bereich, den wir gerade geschrieben haben und fügen ihn einfach darunter noch mal ein.

//Seitenhalterung 1
translate([0,$bfh,$gd])difference(){
cube([$bf + 1,10,$br]);
translate([($bf + 1) / 2, -1,(($br – $lo) / 2)])rotate([-90,0,0])cylinder(h = 10, d = 1.5);
translate([($bf + 1) / 2, -1,(($br – $lo) / 2) + $lo])rotate([-90,0,0])cylinder(h = 10, d = 1.5);
}

//Seitenhalterung 1
translate([0,$bfh,$gd])difference(){
cube([$bf + 1,10,$br]);
translate([($bf + 1) / 2, -1,(($br – $lo) / 2)])rotate([-90,0,0])cylinder(h = 10, d = 1.5);
translate([($bf + 1) / 2, -1,(($br – $lo) / 2) + $lo])rotate([-90,0,0])cylinder(h = 10, d = 1.5);
}

Die Überschrift ändern wir nach Seitenhalterung 2. Nun müssen wir nur noch einen einzigen Wert anpassen, nämlich die 0 beim ersten translate Befehl. Statt 0 muss hier die Breite der Grundplatte abzüglich der Breite des “Befestigungsklötzchens” eingetragen werden. Also

//Seitenhalterung 2
translate([$la +$bf + $bf + 2 – ($bf + 1),$bfh,$gd])difference(){
cube([$bf + 1,10,$br]);
translate([($bf + 1) / 2, -1,(($br – $lo) / 2)])rotate([-90,0,0])cylinder(h = 10, d = 1.5);
translate([($bf + 1) / 2, -1,(($br – $lo) / 2) + $lo])rotate([-90,0,0])cylinder(h = 10, d = 1.5);
}

Damit ist unser Servo- Halter eigentlich fertig.

Wir können nun Halter für nahezu beliebig große bzw. kleine Servos herstellen.

Nur eigentlich fertig? Nun ja, man kann ihn so ohne Einschränkungen einsetzen, keine Frage. Aber vielleicht geht es ja etwas schöner… Schließlich ist das ein Tutorial, wo man etwas über das Programm lernen können soll…

Eine  Möglichkeit unseren Halter zu verschönern wäre es, die Ecken der Grundplatte abzurunden. Dazu kann man in OpenSCAD die Minkowski Funktion verwenden. Was das bedeutet, kann man bei Interesse am besten direkt in Wikipedia nachlesen.  Man kann unglaublich viel mit dieser OpenSCAD Funktion anstellen. Zu 99% ist das alles aber zu hoch für mich. Unser einfacher Anwendungsfall lässt sich aber noch ganz gut erklären und anwenden…

Wir fügen zuerst bei der Grundplatte einen Zylinder ein. Dieser soll eine Höhe von 0.1 und einen Durchmesser von 4 bekommen. Nun bilden wir die Minkowski Summe dieser Objekte.

minkowski()
{
cube([$la +$bf + $bf + 2,$ho,$gd]);
cylinder(h = 0.1, d = 4);
}

Das Ergebnis überrascht ein wenig:

Zumindest, wenn man so wie ich, keine Ahnung von der Minkowski Summe hat. Prinzipiell ist es in diesem Fall so, das die Höhe des Zylinders zur Höhe der Grundplatte hinzugefügt wird und der Durchmesser je zur Länge und zur Breite. Deswegen ist die Platte nun deutlich größer und man versteht vielleicht, warum ich nur 0.1 als Höhe für den Zylinder gewählt habe. 0 geht nicht, dann passiert überhaupt nichts. Und der Durchmesser des Zylinders bestimmt den Radius der Ecken, weswegen man ihn nicht beliebig klein machen kann… Man kann das Ganze zwar auch so lassen. Der Zehntelmillimeter in der Dicke stört überhaupt nicht und das die Platte ein paar Millimeter übersteht ist eigentlich auch egal. Aber trotzdem werden wir das korrigieren.  Wir müssen also die Werte bei cube anpassen, genauer verkleinern. Der X und Y Wert muss je um den Durchmesser des Zylinders verringert werden, die Höhe des Kubus um die Höhe des Zylinders.

minkowski()
{
cube([($la +$bf + $bf + 2)-4,$ho-4,$gd-0.1]);
cylinder(h = 0.1, d = 4);
}

Jetzt stimmen die Abmessungen der Grundplatte wieder, aber dafür ist sie jetzt verrutscht. Also korrigieren wir auch das, in dem wir noch ein translate Befehl einbauen:

translate([2,2,0])minkowski()
{
cube([($la +$bf + $bf + 2)-4,$ho-4,$gd-0.1]);
cylinder(h = 0.1, d = 4);
}

Und nun haben wir die Grundplatte mit abgerundeten Ecken in der vorgesehenen Größe.

Eine Sache stört mich aber immer noch. Die Kanten sind nicht wirklich rund. Das hatten wir doch schon mal… Klar, wir haben vergessen die Auflösung bei dem Zylinder anzugeben,

translate([2,2,0])minkowski()
{
cube([($la +$bf + $bf + 2)-4,$ho-4,$gd-0.1]);
cylinder(h = 0.1, d = 4, $fn = 300);
}

Jetzt sind die Rundungen auch wirklich rund.

Nun speichern wir das Projekt noch einmal. Anschließend können wir es rendern. Das wird eine ganze Weile dauern, da inzwischen doch einige Dreiecke zu berechnen sind…

Anschließend exportieren wir das Objekt als STL Datei und können unseren Servo Halter ausdrucken. Benötigen wir andere Größen, müssen wir nur das Projekt öffnen, am Anfang die Variablen entsprechend ändern und es ggfs. unter einem anderen Namen wieder speichern. Nun müssen wir es nur erneut rendern, als STL exportieren und die neue Halterung ausdrucken…

Diese Halterung besteht aus nur zwei verschiedenen Grundkörpern, 3 Kuben und 8 Zylindern (wobei wir mal den Zylinder für die Minkowski Summe außen vor lassen), ist also eigentlich nicht gerade ein komplexes Objekt… Nichtsdestotrotz qualmt einem am Anfang dabei sicher der Kopf anständig, oder?

Zum Abschluss noch mal ein Screenshot des fertigen Halters im Slicer:

Nun kann man einen ersten Testdruck machen.  Hier ein paar schnelle Handy- Fotos.

Auf den ersten Blick sieht alles passend aus.

Auf den zweiten Blick auch.

Wenn man aber ganz genau hinschaut, passen die Bohrungen für die Befestigungsschrauben nicht wirklich. Nach kurzem Nachdenken ist auch klar, warum. Wir haben die Löcher mittig in den “Halteklötzchen” positioniert. Doch die sind ja 1 mm breiter als die Befestigungslaschen des Servo. Außerdem haben wir ja bei der Länge des Servo ebenfalls 1 mm zugegeben. Dadurch rutschen die Löcher jetzt ganz an den äußeren rand der Löcher im Flansch. Das Test- Exemplar kann man zwar verwenden, aber so soll das Skript nicht bleiben. Wir müssen also die Zylinder jeweils um  1 mm nach innen verschieben gegenüber der Position, in der sie jetzt sind. Nach all dem Hantieren mit Verschiebungen sollte das kein großer Aufwand sein. Also noch mal OpenSCAD angeschmissen und unser Skript geladen. Für den ersten Halter müssen die Zylinder um  + 1 in X Richtung verschoben werden.

//Seitenhalterung 1
translate([0,$bfh,$gd])difference(){
cube([$bf + 1,10,$br]);
translate([($bf + 1) / 2 + 1, -1,(($br – $lo) / 2)])rotate([-90,0,0])cylinder(h = 10, d = 1.5,$fn = 300);
translate([($bf + 1) / 2 + 1, -1,(($br – $lo) / 2) + $lo])rotate([-90,0,0])cylinder(h = 10, d = 1.5,$fn = 300);
}

Beim zweiten Halter entsprechend um – 1

//Seitenhalterung 2
translate([$la +$bf + $bf + 2 – ($bf + 1),$bfh,$gd])difference(){
cube([$bf + 1,10,$br]);
translate([($bf + 1) / 2 – 1, -1,(($br – $lo) / 2)])rotate([-90,0,0])cylinder(h = 10, d = 1.5,$fn = 300);
translate([($bf + 1) / 2 – 1, -1,(($br – $lo) / 2) + $lo])rotate([-90,0,0])cylinder(h = 10, d = 1.5,$fn = 300);
}

Nun speichern wir das Projekt erneut und rendern es wieder. Danach exportieren wir es wieder als STL, um es erneut auszudrucken. Nun sollte alles passen. Aktuell druckt mein Drucker gerade ein weiteres Pärchen Zuckerrohrloren, weswegen ein zweiter Testdruck noch auf sich warten lässt. Aber in den Slicer laden und die Druckdatei vorbereiten kann ich derweil schon.

Sollte es wider Erwarten immer noch nicht passen, bessere ich hier selbstverständlich nach.

Wer sich nicht wirklich für das Tutorial interessiert, aber gerne den Servo- Halter haben will, hier ist noch mal das komplette, fertige Skript.

// OpenSCAD Tutorial Servo- Halter

// Variablen
$la = 42; //Länge des Servo + 1 mm Spielraum
$br = 20; //Breite des Servo
$ho = 35; //Höhe des Servo
$bf = 8; //Länge des Flansch
$bfh = 11; // Höhe des Flansch
$lo = 10; //Lochabstand
$gd = 3; // Dicke der Grundplatte, nicht unter 2 mm
$dm = 3; //Durchmesser der Befestigungsschrauben

// Grundplatte
difference() {

translate([2,2,0])minkowski()
{
cube([($la +$bf + $bf + 2)-4,$ho-4,$gd-0.1]);
cylinder(h = 0.1, d = 4, $fn = 300);
}
translate([$dm + 1,$dm + 1,-1])cylinder(h=$gd + 2, d=$dm + 0.2, $fn = 300);
translate([$dm + 1,$ho – ($dm + 1),-1])cylinder(h=$gd + 2, d=$dm + 0.2, $fn = 300);
translate([$la +$bf + $bf + 2 – ($dm + 1),$dm + 1,-1])cylinder(h=$gd + 2, d=$dm + 0.2, $fn = 300);
translate([$la +$bf + $bf + 2 – ($dm + 1),$ho – ($dm + 1),-1])cylinder(h=$gd + 2, d=$dm + 0.2, $fn = 300);
}

//Seitenhalterung 1
translate([0,$bfh,$gd])difference(){
cube([$bf + 1,10,$br]);
translate([($bf + 1) / 2 + 1, -1,(($br – $lo) / 2)])rotate([-90,0,0])cylinder(h = 10, d = 1.5,$fn = 300);
translate([($bf + 1) / 2 + 1, -1,(($br – $lo) / 2) + $lo])rotate([-90,0,0])cylinder(h = 10, d = 1.5,$fn = 300);
}

//Seitenhalterung 2
translate([$la +$bf + $bf + 2 – ($bf + 1),$bfh,$gd])difference(){
cube([$bf + 1,10,$br]);
translate([($bf + 1) / 2 – 1, -1,(($br – $lo) / 2)])rotate([-90,0,0])cylinder(h = 10, d = 1.5,$fn = 300);
translate([($bf + 1) / 2 – 1, -1,(($br – $lo) / 2) + $lo])rotate([-90,0,0])cylinder(h = 10, d = 1.5,$fn = 300);
}

Und hier als Zip Archiv zum Download:

Servo_Halter

Im nächsten (und wohl letztem) Teil werden wir dann einen Umbausatz konstruieren, mit dem man aus einem Fleischmann Magic Train Personenwagen einen dazu passenden Packwagen basteln kann. Hier geht es zum Bericht.

Zurück

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.