Viele Tüftler kennen das Problem: Man baut eine schöne Schaltung mit einem Microcontroller wie dem Arduino Nano auf, alles funktioniert – aber am Ende liegen die Bauteile lose auf dem Tisch oder verschwinden in einer improvisierten Tupperdose. Ein ordentliches Gehäuse wäre die Lösung. Doch nicht jeder kommt mit klassischen 3D‑CAD‑Programmen zurecht und scheitert schnell an überladenen Oberflächen, unzähligen Werkzeugen und einer Maus, die scheinbar ein Eigenleben führt.
Die hier vorgestellte Methode richtet sich an Bastlerinnen und Bastler, die für ein kleines Projekt kein komplett neues CAD‑Programm erlernen möchten und trotzdem schnell zu einem passenden und leicht anpassbaren Gehäuse kommen wollen.
Heute möchte ich euch zeigen, wie ich eine Gehäuse erstelle – und zwar ganz ohne künstlerisches Zeichnen, sondern mit Textzeilen.
Die Lösung ist OpenSCAD
Da OpenSCAD per Zeilencode seine Anweisungen erhält, ist das die ideale Lösung um mit Hilfe von KI schnell zu einer brauchbaren Druckvorlage zu kommen.
Stellt euch vor, ihr müsstet kein Bild malen, um ein Gehäuse zu bauen, sondern nur aufschreiben, was ihr wollt: „Ich möchte eine Box, 10 cm breit, mit einem Loch für einen Taster in der Mitte.“ Genau so funktioniert OpenSCAD.
Es ist kostenlos, Open Source und perfekt für alle Tüftler, die lieber logisch denken als freihändig zu modellieren.
Warum das für uns Bastler genial ist:
- Kein „Verzeichnen“ mehr: Wenn ein Loch an Position X soll, dann tippt ihr das ein. Es gibt kein versehentliches Verschieben mit der Maus kurz vor dem Speichern.
- Einmal gedacht, hundertmal gemacht: Habt ihr einmal einen Halter für eine 9V-Batterie als Code-Schnipsel „geschrieben“, könnt ihr diesen in jedes neue Projekt einfach reinkopieren.
- Anpassen per Knopfdruck: Ihr habt statt 5mm-LEDs plötzlich nur noch 3mm-LEDs in der Bastelkiste? Im Code ändert ihr oben eine einzige Zahl, und das ganze Modell – alle Löcher, alle Abstände – passt sich sofort automatisch an.
Ein Beispiel aus der Praxis: Mein LED-Würfel
Für meinen elektronischen Würfel brauchte ich ein sechseckiges Gehäuse. Mit der Maus in einem klassischen CAD-Programm wäre das exakte Ausrichten der sechs LED-Löcher im Kreis eine echte Geduldsprobe.
In OpenSCAD sage ich dem Programm einfach (vereinfacht gesagt): „Nimm ein 5mm-Loch, schiebe es 3 cm nach außen und wiederhole das sechsmal im Kreis alle 60 Grad.“ Das Programm erledigt die Mathe-Arbeit für mich und das Ergebnis ist millimetergenau symmetrisch.
Der ultimative „Cheat-Code“: Euer KI-Assistent
„Aber Dirk“, höre ich euch jetzt sagen, „ich kann doch gar nicht programmieren! Diese Befehle kenne ich doch nicht.“
Keine Sorge, das müsst ihr am Anfang auch gar nicht. Hier kommt der eigentliche Clou ins Spiel, der das Ganze auch für absolute Anfänger kinderleicht macht: Künstliche Intelligenz wie Gemini, ChatGPT, Copilot oder Claude.
Stellt euch die KI wie einen extrem geduldigen, erfahrenen Konstrukteur vor, der neben euch sitzt. Ihr müsst nicht die genaue Syntax von OpenSCAD kennen. Ihr müsst nur in eurer Sprache beschreiben können, was ihr haben wollt.
So einfach funktioniert es: Ihr öffnet eure Lieblings-Chat-KI und beschreibt euer Wunschobjekt wie einem Freund am Telefon.
Hier ist ein Beispiel-Prompt, wie ich die KI nach einem ersten Entwurf für das Würfel-Gehäuse fragen würde:
Mein Prompt an Gemini:
„Ich brauche ein 3D-Modell für OpenSCAD.
Erstelle mir bitte ein sechseckiges Gehäuse (Hexagon) mit einem Durchmesser von 100mm und einer Höhe von 40mm. Die Wandstärke soll 2,5mm betragen.
Der Deckel soll abgerundete Außenkanten haben. Oben auf dem Deckel brauche ich 6 Löcher für 5mm LEDs, die im Kreis angeordnet sind.
Genau in der Mitte des Deckels soll ein größeres Loch mit 12mm Durchmesser für einen Taster sein.
Bitte schreibe mir den passenden OpenSCAD Code dafür, idealerweise mit deutschen Parametern am Anfang, damit ich die Maße später leicht ändern kann.
Füge für jede Zeile Kommentare ein, die mir erklären wo für die jeweilige Zeile ist“
Das Ergebnis? Die KI spuckt euch innerhalb von Sekunden einen fast fertigen, funktionierenden OpenSCAD-Code aus. Den kopiert ihr einfach in das Programm, drückt auf Vorschau (F5) und seht euer Gehäuse.
Ihr könnt dann anfangen, mit den Werten zu spielen, und lernt dabei ganz automatisch, wie der Code funktioniert – ohne jemals ein dickes Handbuch gelesen zu haben.
Fazit: Traut euch ran!
Konstruieren mit Code ist wie Klemmbausteine mit Textbefehlen. Es ist präzise, logisch und verzeiht Fehler, weil man jeden Schritt einfach wieder rückgängig machen kann. Und mit einem KI-Assistenten an der Seite gibt es keine Ausrede mehr, es nicht zu versuchen.
Den kompletten, finalen Code für mein LED-Würfel-Gehäuse (Wird ein Empfänger der anzeigt, wer als erstes beim Quizz die Antwort geben möchte) findet ihr in der kommenden Ausgabe, sofern die bestellten Sender für die DIY-Buzzer rechtzeitig kommen.
Ladet euch OpenSCAD mal herunter, öffnet Gemini in einem zweiten Fenster und fangt einfach an zu „beschreiben“, was ihr bauen wollt. Ihr werdet staunen, wie schnell ihr euer erstes eigenes Teil in den Händen haltet!
// ============================================================================
// SECHSECKIGES ELEKTRONIK-GEHÄUSE FÜR LED Würfel
// 3D-Druck Design für OpenSCAD mit Bodenplatte und Oberteil
// ============================================================================
// ----------------------------------------------------------------------------
// PARAMETER-DEFINITION
// ----------------------------------------------------------------------------
$fn = 64; // Globale Auflösung
// Gehäuse Grundmaße
gehaeuse_durchmesser = 120; // Außendurchmesser Spitze zu Spitze
gehaeuse_hoehe = 40; // Gesamthöhe des Gehäuses
wandstaerke = 2.5; // Wandstärke
toleranz = 2; // Toleranz für Passung
// Bodenplatte
bodenplatte_dicke = 2.5; // Dicke der Bodenplatte
bodenplatte_durchmesser = gehaeuse_durchmesser - toleranz;
// Platinen-Halterung für Lolin D32 Lite
board_breite = 26; // Breite des Boards
board_laenge = 50; // Länge des Boards
schiene_breite = 2; // Breite der Halteschiene
schiene_hoehe = 3; // Höhe der Schiene über der Platte
schiene_wandstaerke = 1.5; // Dicke der Schienenwand
einsteck_spalt = 0.3; // Toleranz für das Einschieben
// Gehäuse-Befestigung
befestigungs_durchmesser = 3.0; // M2 Durchgangsloch
kernloch_m2 = 1.5; // M2 Kernloch Durchmesser
versenkung_durchmesser = 5.5; // Versenkung für Schraubenkopf
versenkung_tiefe = 1.5; // Tiefe der Versenkung
befestigungs_abstand = 50; // Abstand der Befestigungspunkte
// Oberteil (Glocke)
abrundung_radius = 2; // Radius für abgerundete Kanten
einkerbung_tiefe = 2; // Tiefe der Einkerbung für Bodenplatte
schraubdom_durchmesser = 6; // Außendurchmesser der Schraubdome
schraubdom_hoehe = 12; // Höhe der Schraubdome
// Taster und LEDs
taster_durchmesser = 12.4; // Durchmesser des Tasterlochs
led_durchmesser = 5; // Durchmesser der LED-Löcher
led_kreis_radius = 25; // Abstand LEDs zur Mitte
led_offset = 20; // Zusätzlicher Offset (gesamt 45mm)
led_anzahl = 6; // Anzahl der LEDs
// Trennlinien zwischen LEDs
trennlinie_tiefe = 0.8; // Tiefe der Trennlinien
trennlinie_breite = 0.8; // Breite der Trennlinien
// Zahlen-Gravur
zahlen_tiefe = 0.5; // Tiefe der Zahlen-Gravur
zahlen_groesse = 12; // Schriftgröße
// Positions-Offset für Darstellung
darstellung_abstand = 120 + 20; // Abstand zwischen Teilen
// ----------------------------------------------------------------------------
// HAUPTPROGRAMM - AUFRUF DER BAUGRUPPEN
// ----------------------------------------------------------------------------
// Bodenplatte links
bodenplatte();
// Oberteil rechts
translate([darstellung_abstand, 0, 0])
oberteil();
// ----------------------------------------------------------------------------
// MODULE
// ----------------------------------------------------------------------------
// Modul: Sechseck (Hexagon)
// Erzeugt ein regelmäßiges 6-seitiges Polygon
module hexagon(durchmesser, hoehe) {
cylinder(h=hoehe, d=durchmesser, $fn=6);
}
// ----------------------------------------------------------------------------
// Modul: Bodenplatte
// Grundplatte mit Halteschienen für die Platine und Befestigungslöchern
module bodenplatte() {
difference() {
union() {
// Grundplatte als Sechseck
hexagon(bodenplatte_durchmesser, bodenplatte_dicke);
// Zwei Halteschienen rechts und links für das Board (26mm x 50mm)
for (x = [-1, 1]) {
translate([x * (board_breite/2 + schiene_wandstaerke/2), 0, bodenplatte_dicke]) {
// L-förmige Schiene
difference() {
// Äußere Form der Schiene
cube([schiene_wandstaerke, board_laenge, schiene_hoehe], center=true);
// Innere Aussparung für Board (mit Toleranz)
translate([x * schiene_wandstaerke/2, 0, einsteck_spalt])
cube([schiene_breite, board_laenge + 0.2, schiene_hoehe], center=true);
}
}
}
// Befestigungspunkte (Verstärkungen) links und rechts
for (x = [-1, 1]) {
translate([x * befestigungs_abstand, 0, 0])
cylinder(h=bodenplatte_dicke, d=versenkung_durchmesser + 2);
}
}
// Befestigungslöcher mit Versenkung für Gehäuse-Verschraubung
for (x = [-1, 1]) {
translate([x * befestigungs_abstand, 0, 0]) {
// Durchgangsloch M2
translate([0, 0, -0.1])
cylinder(h=bodenplatte_dicke + 0.2, d=befestigungs_durchmesser);
// Versenkung für Schraubenkopf (von unten)
translate([0, 0, -0.1])
cylinder(h=versenkung_tiefe + 0.1, d=versenkung_durchmesser);
}
}
}
}
// ----------------------------------------------------------------------------
// Modul: Oberteil (Glocke)
// Hohles Gehäuse mit Taster, LEDs, Zahlen und Schraubdomen
module oberteil() {
difference() {
union() {
// Hauptkörper: Abgerundete Oberkante mit hull()
difference() {
hull() {
// Untere scharfe Kante
hexagon(gehaeuse_durchmesser, 1);
// Obere verrundete Kante
translate([0, 0, gehaeuse_hoehe - abrundung_radius])
minkowski() {
hexagon(gehaeuse_durchmesser - 2*abrundung_radius, 0.1);
sphere(r=abrundung_radius);
}
}
// Hohlraum im Inneren
translate([0, 0, -1])
hexagon(gehaeuse_durchmesser - 2*wandstaerke, gehaeuse_hoehe - wandstaerke + 1);
}
// Schraubdome links und rechts
for (a = [0, 180]) {
rotate([0, 0, a])
translate([gehaeuse_durchmesser/2 - 4, 0, 0])
cylinder(d=schraubdom_durchmesser, h=schraubdom_hoehe);
}
}
// Einkerbung unten für Bodenplatte
translate([0, 0, -0.1])
hexagon(bodenplatte_durchmesser + 0.4, wandstaerke + 0.1);
// M2 Kernlöcher in den Schraubdomen
for (a = [0, 180]) {
rotate([0, 0, a])
translate([gehaeuse_durchmesser/2 - 4, 0, -1])
cylinder(d=kernloch_m2, h=20);
}
// Zentrales Loch für Taster
translate([0, 0, gehaeuse_hoehe - 5])
cylinder(d=taster_durchmesser, h=10);
// 6 LED-Löcher im Kreis angeordnet
for (a = [0:60:300]) {
rotate([0, 0, a])
translate([led_kreis_radius + led_offset, 0, gehaeuse_hoehe - 5])
cylinder(d=led_durchmesser, h=10);
}
// 6 Trennlinien zwischen den LEDs
for (a = [30:60:330]) {
rotate([0, 0, a])
translate([led_kreis_radius/2, -trennlinie_breite/2, gehaeuse_hoehe - trennlinie_tiefe])
cube([gehaeuse_durchmesser/2, trennlinie_breite, 1]);
}
// Zahlen 1-6 graviert (90° gedreht)
for (i = [0:5]) {
rotate([0, 0, i * 60])
translate([led_kreis_radius + 12, 0, gehaeuse_hoehe - zahlen_tiefe])
rotate([0, 0, 90])
linear_extrude(height=1)
text(str(i+1),
size=zahlen_groesse,
font="Arial:style=Bold",
halign="center",
valign="center");
}
}
}
// ============================================================================
// Exporthinweise:
// - Für 3D-Druck beide Teile als STL exportieren
// - Empfohlene Druckeinstellungen: 0,2mm Schichthöhe, 20% Infill
// ============================================================================Vom OpenSCAD‑Modell zur Druckdatei
Wenn der Code steht und die Vorschau gut aussieht, fehlt nur noch der Export für den 3D‑Drucker:
- In OpenSCAD „richtig“ rendern
- Mit F5 siehst du nur die schnelle Vorschau.
- Für den Export musst du einmal F6 drücken oder im Menü Design → Rendern (CGAL) wählen. Erst dann wird das Modell exakt berechnet.
- Als STL exportieren
- Nach dem Rendern gehst du auf Datei → Exportieren → Als STL exportieren und speicherst die Datei an einem sinnvollen Ort.
- Falls du Bodenplatte und Deckel getrennt drucken willst, kannst du entweder schon im Code nur eines der Module anzeigen (z.B. nur
bodenplatte();) oder die Bauteile später im Slicer auseinanderziehen, sofern dieser das unterstützt.
- STL in den Slicer laden
- Öffne deinen Slicer (z.B. PrusaSlicer, Cura, Bambu Studio) und importiere die STL‑Datei.
- Dort stellst du Material, Schichthöhe und Fülldichte ein. Für Gehäuse reichen meistens 0,2 mm Layerhöhe und 15–20% Infill.
- Achte darauf, dass das Teil plan auf der Druckplatte liegt – insbesondere beim Deckel mit abgerundeten Kanten ggf. einmal drehen, bis die Unterseite korrekt aufliegt.
- G‑Code erzeugen und drucken
- Lass den Slicer den G‑Code berechnen und speichere ihn auf SD‑Karte oder schicke ihn direkt an den Drucker (je nach Setup).
- Jetzt kannst du das Gehäuse ausdrucken und nach dem Abkühlen testen, ob Bodenplatte und Oberteil sauber zusammenpassen. Geringe Toleranzprobleme lassen sich notfalls mit etwas Schleifpapier korrigieren.
Youtube Video: