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

OpenSCAD

OpenSCAD für Anfänger – Teil 2: Syntax, Kommentare und Variablen

Schreibe übersichtlichen OpenSCAD-Code und steuere die Maße deiner Modelle mit Variablen und einfachen Berechnungen.

Veröffentlicht am

6 Minuten Lesezeit · 1 PDF-Download

Voraussetzungen

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

Im ersten Teil unseres OpenSCAD-Einsteigerkurses haben wir bereits unser erstes 3D-Modell erstellt und gelernt, wie OpenSCAD grundsätzlich arbeitet.

Unsere einfache Grundplatte bestand nur aus einer einzigen Zeile:

cube([80, 50, 5]);

Für sehr einfache Modelle reicht das bereits aus.

Sobald Modelle aber größer oder häufiger verändert werden sollen, ist es sinnvoll, feste Zahlen durch Variablen zu ersetzen.

In dieser Lektion beschäftigen wir uns deshalb mit der grundlegenden Syntax von OpenSCAD, Kommentaren, Variablen und einfachen Berechnungen.

Lernziel: Nach dieser Lektion kannst du OpenSCAD-Code sauber strukturieren, Kommentare verwenden, eigene Variablen definieren und einfache parametrische Abhängigkeiten aufbauen.

Aufbau eines OpenSCAD-Befehls

Ein einfacher OpenSCAD-Befehl kann beispielsweise so aussehen:

cube([80, 50, 5]);

Dieser Befehl besteht aus mehreren Elementen:

Bestandteil Bedeutung
cube Name des Befehls
( ) enthält die Parameter des Befehls
[ ] enthält eine Liste mehrerer Werte
80, 50, 5 Werte für X, Y und Z
; beendet den Befehl

Die drei Werte entsprechen der Größe des Quaders in X-, Y- und Z-Richtung.

Das Semikolon

Viele Anweisungen in OpenSCAD enden mit einem Semikolon.

Beispiel:

cube([80, 50, 5]);

Wird das Semikolon vergessen, kann OpenSCAD den Code unter Umständen nicht korrekt interpretieren.

Beispiel mit Fehler:

cube([80, 50, 5])

Beim Aktualisieren der Vorschau zeigt OpenSCAD eine Fehlermeldung an.

Typische Syntaxfehler sind:

  • fehlendes Semikolon

  • fehlende Klammer

  • falsche Klammer

  • fehlendes Komma

  • Schreibfehler im Befehlsnamen

Gerade als Anfänger gehören solche Fehler ganz normal zum Arbeiten mit OpenSCAD.

Kommentare verwenden

Kommentare helfen dabei, den eigenen Code verständlich zu halten.

Sie werden von OpenSCAD ignoriert und beeinflussen das Modell nicht.

Einzeilige Kommentare

Ein einzeiliger Kommentar beginnt mit zwei Schrägstrichen:

// Meine erste Grundplatte

cube([80, 50, 5]);

Alles hinter // wird in dieser Zeile als Kommentar behandelt.

Kommentare eignen sich beispielsweise für:

  • kurze Erklärungen

  • Hinweise zu Parametern

  • Versionsinformationen

  • Notizen

  • Gliederungen innerhalb des Codes

Mehrzeilige Kommentare

Für längere Kommentare können wir folgende Schreibweise verwenden:

/*
  Grundplatte für die Übung

  Breite: 80 mm
  Tiefe: 50 mm
  Höhe: 5 mm
*/

cube([80, 50, 5]);

Alles zwischen /* und */ wird als Kommentar behandelt.

Warum Variablen?

Unser bisheriges Modell verwendet direkt feste Zahlen:

cube([80, 50, 5]);

Das funktioniert, ist aber bei komplexeren Modellen unpraktisch.

Stattdessen können wir Werte in Variablen speichern:

breite = 80;
tiefe = 50;
hoehe = 5;

cube([breite, tiefe, hoehe]);

Das Ergebnis ist identisch.

Der Unterschied liegt im Aufbau des Modells.

Statt direkt mit festen Zahlen zu arbeiten, verwenden wir jetzt benannte Parameter.

Dadurch lässt sich der Code wesentlich leichter lesen und verändern.

Parameter ändern

Möchten wir eine andere Variante der Grundplatte erzeugen, müssen wir jetzt nur noch die Variablen ändern.

Zum Beispiel:

breite = 100;
tiefe = 60;
hoehe = 4;

cube([breite, tiefe, hoehe]);

Nach dem Aktualisieren der Vorschau wird automatisch die neue Variante erzeugt.

Genau darin liegt eine der großen Stärken von OpenSCAD.

Die Geometrie bleibt grundsätzlich gleich, während sich ihre Parameter verändern lassen.

Sinnvolle Variablennamen

Variablen sollten möglichst aussagekräftige Namen besitzen.

Technisch möglich wäre beispielsweise:

b = 80;
t = 50;
h = 5;

Bei kleinen Beispielen kann das ausreichend sein.

Lesbarer ist häufig:

breite = 80;
tiefe = 50;
hoehe = 5;

Gerade bei größeren Projekten ist sofort erkennbar, welche Bedeutung die Werte haben.

Ein guter Variablenname sollte möglichst direkt beschreiben, wofür der Wert verwendet wird.

Beispiele:

breite = 80;
wandstaerke = 3;
lochdurchmesser = 5;
rand = 8;

Welche Einheit verwendet OpenSCAD?

OpenSCAD schreibt grundsätzlich keine feste Einheit vor.

Für Modelle, die später für den 3D-Druck verwendet werden, wird üblicherweise in Millimetern gearbeitet.

Wenn wir schreiben:

breite = 80;

behandeln wir diesen Wert daher normalerweise als:

80 mm

Die Einheit selbst wird nicht in den Code geschrieben.

Nicht so:

breite = 80mm;

sondern:

breite = 80;

Mit Variablen rechnen

Variablen können nicht nur feste Zahlen enthalten.

Sie können auch aus anderen Variablen berechnet werden.

Beispiel:

breite = 80;

halbe_breite = breite / 2;

Der Wert von halbe_breite beträgt automatisch 40.

Ändern wir später:

breite = 100;

wird halbe_breite automatisch zu 50.

Diese Abhängigkeiten sind die Grundlage für parametrisches Konstruieren.

Grundrechenarten

OpenSCAD unterstützt natürlich die grundlegenden mathematischen Operationen.

Operation Zeichen Beispiel
Addition + breite + 10
Subtraktion - breite - 10
Multiplikation * breite * 2
Division / breite / 2

Beispiele:

doppelte_breite = breite * 2;
halbe_breite = breite / 2;
gesamtbreite = breite + 20;
innenbreite = breite - 10;

Abhängige Maße

Besonders interessant wird es, wenn Maße voneinander abhängen.

Nehmen wir an, unsere Grundplatte besitzt einen Rand von 5 mm:

breite = 80;
tiefe = 50;
rand = 5;

Die Innenbreite können wir dann automatisch berechnen:

innenbreite = breite - 2 * rand;

Warum 2 * rand?

Weil sich sowohl auf der linken als auch auf der rechten Seite ein Rand befindet.

Für die Tiefe gilt entsprechend:

innentiefe = tiefe - 2 * rand;

Der komplette Bereich sieht damit so aus:

breite = 80;
tiefe = 50;
hoehe = 5;

rand = 5;

innenbreite = breite - 2 * rand;
innentiefe = tiefe - 2 * rand;

cube([breite, tiefe, hoehe]);

Noch verwenden wir innenbreite und innentiefe nicht direkt für eine sichtbare Geometrie.

Später können wir solche Werte beispielsweise für:

  • Ausschnitte

  • Bohrungen

  • Gehäuseinnenräume

  • Lochabstände

  • Wandstärken

verwenden.

Code sinnvoll strukturieren

Bei größeren Modellen lohnt es sich, den Code bereits von Anfang an übersichtlich aufzubauen.

Eine mögliche Struktur ist:

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

breite = 80;
tiefe = 50;
hoehe = 5;

rand = 5;

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

innenbreite = breite - 2 * rand;
innentiefe = tiefe - 2 * rand;

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

cube([breite, tiefe, hoehe]);

Eine solche Struktur ist keine feste Vorgabe.

Sie hilft aber enorm dabei, größere Modelle später noch nachvollziehen und verändern zu können.

Parametrisch statt feste Werte

Vergleichen wir beide Varianten noch einmal.

Feste Werte

cube([80, 50, 5]);

Parametrische Variante

breite = 80;
tiefe = 50;
hoehe = 5;

cube([breite, tiefe, hoehe]);

Beide erzeugen zunächst dasselbe Modell.

Die zweite Variante lässt sich aber wesentlich einfacher anpassen und erweitern.

Damit haben wir den ersten wichtigen Schritt vom einfachen OpenSCAD-Modell hin zu einer echten parametrischen Konstruktion gemacht.

Mitmach-Aufgabe

Erstelle eine parametrische Grundplatte mit folgenden Werten:

Parameter Wert
Breite 100 mm
Tiefe 60 mm
Höhe 4 mm
Rand 8 mm

Berechne zusätzlich:

  • Innenbreite

  • Innentiefe

  • halbe Breite

Versuche die Aufgabe zunächst selbst zu lösen.

Musterlösung

Eine mögliche Lösung sieht so aus:

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

breite = 100;
tiefe = 60;
hoehe = 4;

rand = 8;

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

innenbreite = breite - 2 * rand;
innentiefe = tiefe - 2 * rand;

halbe_breite = breite / 2;

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

cube([breite, tiefe, hoehe]);

Ändere anschließend beispielsweise:

breite = 120;

Die Werte für innenbreite und halbe_breite passen sich automatisch an.

Was haben wir gelernt?

Nach dieser Lektion kennst du bereits weitere wichtige Grundlagen von OpenSCAD:

  • Befehle besitzen eine feste Syntax.

  • Viele Anweisungen enden mit einem Semikolon.

  • // erzeugt einen einzeiligen Kommentar.

  • /* ... */ erzeugt einen mehrzeiligen Kommentar.

  • Werte können in Variablen gespeichert werden.

  • Variablen können sprechende Namen erhalten.

  • Werte können aus anderen Variablen berechnet werden.

  • Modelle lassen sich dadurch parametrisch aufbauen.

Mit diesem Wissen können wir unsere Modelle deutlich sauberer und flexibler gestalten.

Im nächsten Teil

Im dritten Teil beschäftigen wir uns mit den wichtigsten 3D-Grundkörpern in OpenSCAD.

Dazu gehören:

cube();
cylinder();
sphere();

Wir sehen uns an, welche Parameter diese Körper besitzen und wie wir ihre Größe beeinflussen können.

Außerdem beschäftigen wir uns erstmals genauer mit runden Geometrien und der Frage, warum ein Kreis in einem 3D-Modell eigentlich aus vielen kleinen geraden Segmenten besteht.

Am Ende bauen wir daraus ein kleines, druckbares Bauteil.

Passendes Cheatsheet

Im Cheatsheet „Grundbefehle und Syntax“ findest du die Befehle dieser Lektion kompakt zum Nachschlagen. Du kannst das Cheatsheet auch direkt als PDF herunterladen.