Suche
MenüSchließen
OpenSCAD für Anfänger · Teil 12TutorialEinsteiger

OpenSCAD

OpenSCAD für Anfänger – Teil 12: Eigene Module erstellen

Definiere wiederverwendbare Geometrien mit module, nutze Parameter und Standardwerte und strukturiere eine Montageplatte mit eigenen Bausteinen.

Veröffentlicht am · Aktualisiert am

4 Minuten Lesezeit · 1 PDF-Download

Eigene Module machen OpenSCAD-Geometrien wiederverwendbar. Du definierst Bausteine für Bohrungen, Grundplatten und Abstandshalter, übergibst ihnen Parameter und setzt daraus übersichtliche Modelle mit mehreren Varianten zusammen.

Voraussetzungen

Du brauchst OpenSCAD und die Grundlagen aus Teil 11 des Kurses.

Kapitel 3 – OpenSCAD automatisieren

In den bisherigen Lektionen haben wir bereits gelernt, wie sich OpenSCAD-Modelle parametrisch aufbauen, mit Schleifen automatisieren und mit Bedingungen verändern lassen.

Mit eigenen Modulen gehen wir jetzt einen weiteren wichtigen Schritt.

Ein Modul fasst eine Geometrie oder einen wiederkehrenden Codeblock unter einem eigenen Namen zusammen.

Die allgemeine Schreibweise lautet:

module name() {

    // Geometrie

}

Das Modul kann anschließend wie ein eigener OpenSCAD-Befehl aufgerufen werden.

Lernziel:
Nach dieser Lektion kannst du eigene Module definieren, Parameter und Standardwerte verwenden und wiederkehrende Geometrien in übersichtliche Bausteine zerlegen.

Warum eigene Module?

Nehmen wir einen einfachen Abstandshalter:

difference() {

    cylinder(
        h=20,
        d=15,
        $fn=64
    );

    translate([0, 0, -1])
        cylinder(
            h=22,
            d=5,
            $fn=64
        );
}

Wird dieser Abstandshalter mehrfach benötigt, müssten wir den gleichen Code immer wieder kopieren.

Das funktioniert zwar, führt aber schnell zu:

  • langem Quelltext

  • doppeltem Code

  • unnötiger Fehlergefahr

  • schlechter Wartbarkeit

Ein Modul löst genau dieses Problem.

Das erste eigene OpenSCAD-Modul definieren

module abstandshalter() {

    cylinder(
        h=20,
        d=15,
        $fn=64
    );
}

Aufgerufen wird das Modul mit:

abstandshalter();

Damit verhält sich abstandshalter() für unser Modell wie ein eigener Befehl.

Module mehrfach verwenden

module abstandshalter() {

    cylinder(
        h=20,
        d=15,
        $fn=64
    );
}

translate([0, 0, 0])
    abstandshalter();

translate([30, 0, 0])
    abstandshalter();

translate([60, 0, 0])
    abstandshalter();

Die Geometrie selbst wurde nur einmal definiert.

Parameter an ein Modul übergeben

Ein Modul kann Parameter erhalten:

module abstandshalter(
    aussen_d,
    hoehe
) {

    cylinder(
        h=hoehe,
        d=aussen_d,
        $fn=64
    );
}

Aufruf:

abstandshalter(15, 20);

Damit werden die Werte beim Aufruf an das Modul übergeben.

Benannte Parameter

Lesbarer ist häufig:

abstandshalter(
    aussen_d=15,
    hoehe=20
);

Gerade bei mehreren Parametern ist die Bedeutung der Werte dadurch sofort erkennbar.

Standardwerte

Parameter können bereits in der Moduldefinition Standardwerte erhalten:

module abstandshalter(
    aussen_d=15,
    hoehe=20
) {

    cylinder(
        h=hoehe,
        d=aussen_d,
        $fn=64
    );
}

Dann ist auch folgender Aufruf möglich:

abstandshalter();

In diesem Fall werden automatisch:

  • Außendurchmesser = 15 mm

  • Höhe = 20 mm

verwendet.

Parametrischer Abstandshalter mit Bohrung

Jetzt erweitern wir das Modul:

module abstandshalter(
    aussen_d=15,
    bohrung_d=5,
    hoehe=20
) {

    difference() {

        cylinder(
            h=hoehe,
            d=aussen_d,
            $fn=64
        );

        translate([
            0,
            0,
            -1
        ])
            cylinder(
                h=hoehe + 2,
                d=bohrung_d,
                $fn=64
            );
    }
}

Mehrere Varianten mit demselben Modul

translate([0, 0, 0])
    abstandshalter(
        aussen_d=15,
        bohrung_d=5,
        hoehe=20
    );

translate([30, 0, 0])
    abstandshalter(
        aussen_d=20,
        bohrung_d=6,
        hoehe=30
    );

translate([70, 0, 0])
    abstandshalter(
        aussen_d=25,
        bohrung_d=8,
        hoehe=15
    );

Damit zeigt sich einer der wichtigsten Vorteile von Modulen:

Die Konstruktionslogik wird nur einmal definiert, während beliebig viele Varianten daraus entstehen können.

Module als Hilfsgeometrie

Ein Modul muss kein fertiges Bauteil sein.

Es kann beispielsweise auch einen wiederverwendbaren Schneidkörper erzeugen.

Beispiel:

module bohrung(
    d=5,
    h=10,
    ueberstand=1
) {

    translate([
        0,
        0,
        -ueberstand
    ])
        cylinder(
            h=h + 2 * ueberstand,
            d=d,
            $fn=64
        );
}

Dadurch müssen wir die für difference() benötigte Überlänge nicht jedes Mal neu berechnen.

Bohrungsmodul verwenden

difference() {

    cube([
        80,
        50,
        5
    ]);

    translate([
        10,
        10,
        0
    ])
        bohrung(
            d=5,
            h=5
        );

    translate([
        70,
        10,
        0
    ])
        bohrung(
            d=5,
            h=5
        );
}

Der Hauptcode beschreibt jetzt wesentlich deutlicher, was eigentlich passieren soll.

Module und Schleifen kombinieren

Module lassen sich direkt innerhalb einer for()-Schleife verwenden:

for (x = [10, 70])
    for (y = [10, 40])
        translate([
            x,
            y,
            0
        ])
            bohrung(
                d=5,
                h=5
            );

Damit erzeugen wir vier Bohrungen mit nur einem einzigen Modulaufruf im Schleifenkörper.

Module und if() kombinieren

Auch optionale Geometrien sind problemlos möglich:

mit_mittelbohrung = true;

if (mit_mittelbohrung)
    translate([
        40,
        25,
        0
    ])
        bohrung(
            d=20,
            h=5
        );

Damit greifen jetzt mehrere Inhalte des Kurses ineinander:

Module
+ Schleifen
+ Bedingungen
+ boolesche Operationen
= flexibel aufgebaute Modelle

Praxisprojekt: Montageplatte modularisieren

Die Montageplatte aus den letzten Lektionen bestand bisher aus:

  • Grundplatte

  • vier Befestigungsbohrungen

  • optionaler Mittelbohrung

Jetzt lagern wir wiederkehrende Geometrien in eigene Module aus.

Modul für die Grundplatte

module grundplatte(
    breite,
    tiefe,
    dicke
) {

    cube([
        breite,
        tiefe,
        dicke
    ]);
}

Modul für Bohrungen

module bohrung(
    d,
    h,
    ueberstand=1
) {

    translate([
        0,
        0,
        -ueberstand
    ])
        cylinder(
            h=h + 2 * ueberstand,
            d=d,
            $fn=64
        );
}

Parameter des Modells

breite = 120;
tiefe = 70;
dicke = 5;

bohrung_d = 6;

rand_x = 12;
rand_y = 12;

mit_mittelbohrung = true;
mittelbohrung_d = 20;

Berechnungen

x_pos = [
    rand_x,
    breite - rand_x
];

y_pos = [
    rand_y,
    tiefe - rand_y
];

Hauptmodell

difference() {

    grundplatte(
        breite=breite,
        tiefe=tiefe,
        dicke=dicke
    );

    for (x = x_pos)
        for (y = y_pos)
            translate([
                x,
                y,
                0
            ])
                bohrung(
                    d=bohrung_d,
                    h=dicke
                );

    if (mit_mittelbohrung)
        translate([
            breite / 2,
            tiefe / 2,
            0
        ])
            bohrung(
                d=mittelbohrung_d,
                h=dicke
            );
}

Der Hauptteil des Modells liest sich jetzt fast wie eine Beschreibung:

  1. Grundplatte erzeugen

  2. Befestigungsbohrungen abziehen

  3. optional Mittelbohrung abziehen

Sinnvolle Modulnamen

Ein Modul sollte möglichst eindeutig benannt werden.

Gut:

bohrung()
grundplatte()
abstandshalter()
winkelhalter()

Weniger hilfreich:

teil1()
objekt()
modul2()
x()

Je größer ein Projekt wird, desto wichtiger werden verständliche Namen.

Module als eigene Bauteilbibliothek

Ein großer Vorteil von Modulen ist ihre Wiederverwendbarkeit.

Mit der Zeit können beispielsweise Module entstehen für:

Bohrungen
Senkungen
Langlöcher
Abstandshalter
Schraubaufnahmen
Halterungen
Gehäuseelemente
Rippen
Steckerausschnitte

Solche Bausteine können später sogar in eigene Dateien ausgelagert und in verschiedenen OpenSCAD-Projekten wiederverwendet werden.

Mit Bibliotheken beschäftigen wir uns später im Kurs noch genauer.

Mitmach-Aufgabe

Erstelle ein eigenes Modul:

halter()

Das Modul soll einen einfachen parametrischen Winkelhalter erzeugen.

Parameter

Parameter Standardwert
Breite 60 mm
Tiefe 30 mm
Höhe 40 mm
Wandstärke 5 mm

Verwende innerhalb des Moduls:

union()
cube()
translate()

Erzeuge anschließend zwei verschiedene Varianten des Halters.

Musterlösung

module halter(
    breite=60,
    tiefe=30,
    hoehe=40,
    wand=5
) {

    union() {

        // Grundplatte
        cube([
            breite,
            tiefe,
            wand
        ]);

        // Rückwand
        translate([
            0,
            0,
            wand
        ])
            cube([
                breite,
                wand,
                hoehe - wand
            ]);
    }
}

// Variante 1

translate([
    0,
    0,
    0
])
    halter(
        breite=60,
        tiefe=30,
        hoehe=40,
        wand=5
    );

// Variante 2

translate([
    80,
    0,
    0
])
    halter(
        breite=80,
        tiefe=40,
        hoehe=50,
        wand=6
    );

Was haben wir gelernt?

Mit:

module

können wir eigene wiederverwendbare Bausteine definieren.

Module können:

  • Geometrie zusammenfassen

  • Parameter erhalten

  • Standardwerte verwenden

  • beliebig oft aufgerufen werden

  • unterschiedliche Varianten erzeugen

  • mit for() kombiniert werden

  • mit if() kombiniert werden

  • als Hilfsgeometrien dienen

  • komplexe Modelle deutlich übersichtlicher machen

Damit verfügen wir über ein sehr wichtiges Werkzeug für größere OpenSCAD-Projekte.

Im nächsten Teil

Im nächsten Teil geht es um:

function

Module erzeugen normalerweise Geometrie.

Funktionen dagegen berechnen Werte und geben diese zurück.

Damit können wir beispielsweise:

  • Maße berechnen

  • Durchmesser ableiten

  • Positionen bestimmen

  • wiederkehrende Formeln zentral definieren

So wird unsere parametrische Konstruktion noch flexibler.

Häufige Fragen

Wie definiere und verwende ich ein OpenSCAD-Modul?

Definiere den Baustein mit module name(parameter) { ... } und rufe ihn mit name(wert); auf. Die Geometrie im Modul wird an der Stelle des Aufrufs erzeugt.

Wann sind Standardwerte für Modulparameter sinnvoll?

Standardwerte eignen sich für häufig verwendete Abmessungen. Ein Modul wie module halter(breite=60) kann ohne Argument aufgerufen werden; mit halter(breite=80); erzeugst du gezielt eine andere Variante.

Passendes Cheatsheet

Im Cheatsheet „Schleifen, Bedingungen und Module“ findest du ergänzende Grundlagen zum Nachschlagen. Du kannst das Cheatsheet auch direkt als PDF herunterladen.

Weiterlernen