OpenSCAD für Anfänger – Teil 13: Eigene Funktionen mit function()

Mit function definierst du in OpenSCAD wiederverwendbare Berechnungen. Dieses Tutorial zeigt, wie du Innenmaße und Bohrungspositionen berechnest, Ergebnisse mit echo() prüfst und Funktionen mit Geometriemodulen kombinierst.

Voraussetzungen

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

Kapitel 3 – OpenSCAD automatisieren

Im vorherigen Teil haben wir gelernt, wie sich mit module eigene wiederverwendbare Geometrien definieren lassen.

Jetzt beschäftigen wir uns mit einem ähnlichen Konzept für Berechnungen:

function

Eine Funktion nimmt Werte entgegen, führt eine Berechnung durch und liefert anschließend einen Wert zurück.

Lernziel:
Nach dieser Lektion kannst du eigene Funktionen definieren und wiederkehrende Berechnungen zentral in deinem OpenSCAD-Modell ablegen.

Modul oder Funktion?

Der Unterschied lässt sich für den Einstieg sehr einfach zusammenfassen.

Modul

Ein Modul erzeugt normalerweise Geometrie:

module bohrung() {
    cylinder(
        h=10,
        d=5
    );
}

Funktion

Eine Funktion berechnet einen Wert:

function doppelt(x)
    = x * 2;

Die erste OpenSCAD-Funktion mit function definieren

Die allgemeine Schreibweise lautet:

function name(parameter)
    = berechnung;

Ein einfaches Beispiel:

function doppelt(x)
    = x * 2;

Aufruf:

wert = doppelt(10);

Der zurückgegebene Wert beträgt:

20

Ergebnisse mit echo() anzeigen

Zum Testen einer Funktion eignet sich:

echo();

Beispiel:

function doppelt(x)
    = x * 2;

wert = doppelt(10);

echo(wert);

Die Ausgabe erscheint in der OpenSCAD-Konsole.

Funktionen direkt verwenden

Das Ergebnis muss nicht zuerst in einer Variablen gespeichert werden.

function doppelt(x)
    = x * 2;

cube([
    doppelt(20),
    30,
    5
]);

Die X-Abmessung des Quaders beträgt damit 40 mm.

Funktionen mit mehreren Parametern

Ein sehr praktisches Beispiel ist die Berechnung eines Innenmaßes:

function innenmass(
    aussen,
    wand
) = aussen - 2 * wand;

Verwendung:

innenbreite = innenmass(
    80,
    3
);

Ergebnis:

74

Warum Funktionen verwenden?

Natürlich könnten wir direkt schreiben:

innenbreite =
    breite - 2 * wand;

Eine Funktion ist besonders dann sinnvoll, wenn dieselbe Berechnung:

• mehrfach benötigt wird

• komplexer ist

• einen klaren fachlichen Namen bekommen soll

• später zentral geändert werden soll

Beispiel:

innenmass(breite, wand)

beschreibt sehr deutlich, was berechnet wird.

Mittelpunkt berechnen

Eine häufige Berechnung lautet:

gesamt / 2

Dafür können wir eine Funktion erstellen:

function mitte(
    gesamt
) = gesamt / 2;

Verwendung:

x = mitte(breite);
y = mitte(tiefe);

Position vom rechten Rand

Auch eine Position auf der gegenüberliegenden Seite lässt sich als Funktion ausdrücken:

function pos_rechts(
    gesamt,
    rand
) = gesamt - rand;

Beispiel:

rechte_position =
    pos_rechts(
        breite,
        rand
    );

Standardwerte in Funktionen

Funktionen können Standardwerte besitzen:

function innenmass(
    aussen,
    wand=3
) = aussen - 2 * wand;

Damit funktioniert:

innenmass(80);

mit einer automatischen Wandstärke von 3 mm.

Alternativ:

innenmass(80, 5);

mit einer explizit angegebenen Wandstärke.

Bedingungen innerhalb einer Funktion

Auch einfache Entscheidungen können Teil einer Funktion sein.

Beispiel:

function mindestwert(
    wert,
    minimum
) =
    wert < minimum
        ? minimum
        : wert;

Die verwendete Schreibweise lautet:

Bedingung
?
Wert wenn wahr
:
Wert wenn falsch

Beispiel:

mindestwert(2, 5)

liefert:

5

während:

mindestwert(8, 5)

den Wert:

8

zurückgibt.

Für den Einsteigerkurs reicht es zunächst aus, diese Möglichkeit kennenzulernen.

Praxisprojekt: Montageplatte mit Funktionen

Wir greifen erneut unsere Montageplatte aus den vorherigen Lektionen auf.

Jetzt lagern wir einige Berechnungen in eigene Funktionen aus.

Funktionen definieren

function pos_rechts(
    gesamt,
    rand
) = gesamt - rand;

function mitte(
    gesamt
) = gesamt / 2;

function innenmass(
    aussen,
    rand
) = aussen - 2 * rand;

Parameter

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

bohrung_d = 6;

rand_x = 12;
rand_y = 12;

mit_mittelbohrung = true;
mittelbohrung_d = 20;

Bohrungspositionen berechnen

x_pos = [
    rand_x,
    pos_rechts(
        breite,
        rand_x
    )
];

y_pos = [
    rand_y,
    pos_rechts(
        tiefe,
        rand_y
    )
];

Der Vorteil:

Die eigentliche Bedeutung der Berechnung ist jetzt direkt im Namen erkennbar.

Mittelbohrung positionieren

Statt:

breite / 2

und:

tiefe / 2

verwenden wir:

mitte(breite)
mitte(tiefe)

Zum Beispiel:

translate([
    mitte(breite),
    mitte(tiefe),
    0
])
    bohrung(
        d=mittelbohrung_d,
        h=dicke
    );

Vollständiges Beispiel

// -------------------------
// Parameter
// -------------------------

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

bohrung_d = 6;

rand_x = 12;
rand_y = 12;

mit_mittelbohrung = true;
mittelbohrung_d = 20;

// -------------------------
// Funktionen
// -------------------------

function pos_rechts(
    gesamt,
    rand
) = gesamt - rand;

function mitte(
    gesamt
) = gesamt / 2;

function innenmass(
    aussen,
    rand
) = aussen - 2 * rand;

// -------------------------
// Berechnungen
// -------------------------

x_pos = [
    rand_x,
    pos_rechts(
        breite,
        rand_x
    )
];

y_pos = [
    rand_y,
    pos_rechts(
        tiefe,
        rand_y
    )
];

// -------------------------
// Module
// -------------------------

module grundplatte(
    breite,
    tiefe,
    dicke
) {
    cube([
        breite,
        tiefe,
        dicke
    ]);
}

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

// -------------------------
// Modell
// -------------------------

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([
            mitte(breite),
            mitte(tiefe),
            0
        ])
            bohrung(
                d=mittelbohrung_d,
                h=dicke
            );
}

Wann Funktion, wann Variable?

Für eine einmalige sehr einfache Berechnung reicht häufig eine Variable:

mitte_x = breite / 2;

Eine Funktion ist besonders hilfreich, wenn die gleiche Berechnung an mehreren Stellen benötigt wird:

mitte(breite)
mitte(tiefe)
mitte(hoehe)

Dadurch wird die Logik wiederverwendbar.

Funktion oder Modul?

Eine einfache Faustregel:

Beispiele:

breite = 100;

Variable

mitte(breite)

Funktion

bohrung(d=5, h=10);

Modul

Mitmach-Aufgabe

Erstelle drei Funktionen:

mitte()
innenmass()
pos_rechts()

Vorgaben

breite = 100;
tiefe = 60;
wand = 5;
rand = 10;

Berechne:

• Mittelpunkt der Breite

• Mittelpunkt der Tiefe

• Innenbreite

• Position 10 mm vom rechten Rand

Gib die Ergebnisse mit echo() aus.

Musterlösung

function mitte(
    gesamt
) = gesamt / 2;

function innenmass(
    aussen,
    wand
) = aussen - 2 * wand;

function pos_rechts(
    gesamt,
    rand
) = gesamt - rand;

breite = 100;
tiefe = 60;
wand = 5;
rand = 10;

echo(
    "Mitte Breite:",
    mitte(breite)
);

echo(
    "Mitte Tiefe:",
    mitte(tiefe)
);

echo(
    "Innenbreite:",
    innenmass(
        breite,
        wand
    )
);

echo(
    "Position rechts:",
    pos_rechts(
        breite,
        rand
    )
);

Was haben wir gelernt?

Mit:

function

können eigene Berechnungen definiert werden.

Funktionen können:

• Parameter erhalten

• Standardwerte besitzen

• Berechnungen kapseln

• einen Wert zurückgeben

• direkt in anderen Ausdrücken verwendet werden

• wiederkehrende Formeln zentralisieren

• parametrischen Code besser lesbar machen

Zusammen mit:

for()
if()
module
function

besitzen wir inzwischen eine sehr gute Grundlage für automatisierte und wiederverwendbare OpenSCAD-Modelle.

Im nächsten Teil

Mit Teil 14 wechseln wir zunächst zu den zweidimensionalen Grundformen.

Wir lernen:

square()
circle()
polygon()

Diese Formen sind besonders wichtig, weil wir daraus später über:

linear_extrude()
rotate_extrude()

wieder dreidimensionale Bauteile erzeugen können.

Damit beginnt ein neuer Bereich des OpenSCAD-Kurses.

Häufige Fragen

Was ist der Unterschied zwischen function und module?

Eine Funktion liefert einen Wert zurück, etwa ein Maß oder eine Position. Ein Modul erzeugt oder verarbeitet Geometrie. Den Rückgabewert einer Funktion kannst du als Argument an ein Modul übergeben.

Kann ich if/else innerhalb einer Funktion verwenden?

Für die hier gezeigten bedingten Rückgabewerte verwendest du den ternären Operator bedingung ? wert_wenn_wahr : wert_wenn_falsch. Die if/else-Anweisung aus Teil 11 steuert dagegen die Erzeugung von Geometrie.

Passendes Cheatsheet

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

Weiter geht es mit Teil 14: 2D-Grundformen mit square(), circle() und polygon().

Weiterlernen

• OpenSCAD-Syntax und Grundbefehle
• OpenSCAD für Anfänger: alle Kursteile
• Teil 14: 2D-Grundformen in OpenSCAD