3D-Baukasten

Praktikum vom 11.03.-14.04.13

{autotoc}

 

!! Im Aufbau !!

 

1. Beschreibung der Tätigkeit:

Ziel der Ingenieurpraxis ist die Entwicklung eines 3D-Baukastens. Dieser soll zur Konstruktion von Prototypen eingesetzt werden. Es soll eine Vielzahl von Bauteilen entstehen. Die Modelle, die mit diesen Bauteilen entworfen werden, könnten zum Beispiel Kammerahalterungen oder ein Skelett für einen Quadrocopter sein. Die Bauteile  werden mit einem 3D-Drucker ausgedruckt. Dieser Vorgang soll mit einem Programm vereinfacht werden, welches in der Programmiersprache Python geschrieben ist. Mit Dem Programm kann man die Teile für das jeweilige Projekt anpassen.

 

2. Verwendete Software und Programmiersprachen

2.1 Software des 3D-Druckers

Für den 3D-Drucker werden die Programme Slic3r und Printrun verwendet.

Slic3r ist ein Slicer-Programm/Toolchain basierend auf Perl und C++. Es wandelt STL-Dateien in GCode um. Der GCode enthält Informationen, die der 3D-Drucker benötigt um ein Objekt zu drucken. Eine ausführlichere Dokumentation zum Thema Slic3r findet sich beim Projekt 3D-Drucker.


Um mit dem 3D-Drucker Bauteile drucken zu können muss man diese zunächst mit einem CAD-Programm entwerfen und dann als STL-Datei Exportieren. Dann wird die STL-Datein mit Slic3r in GCode umgewandelt und dass Bauteil kann mit dem 3D-Drucker ausgedruckt werden.

2.2 Open-SCAD(OpenSCAD - The Programmers Solid 3D CAD Modeller)

Open-SCAD ist eine kostenlose Software um 3D-Objekte zu erzeugen. Die Software ist für Linux, Windows und Mac OS X erhältlich.

Open-SCAD arbeitet mit script file's, wie eine Art 3D-compiler. Aus dem script file wird dann das 3D-Objekt gerendert.

Anleitung:http://en.wikibooks.org/wiki/OpenSCAD_User_Manual

Cheat Sheet

2.3 Python

Python ist einer höhere Programmiersprache, die 1991 als Ersatz für die Programmiersprache ABC entwickelt wurde.

Verwendete Tutorials:

2.4 Tkinter

Tkinter (Tk interface) ist eine der am Häufigsten verwendeten GUI für Python. Es ist ein Tool-kit um graphische Benutzeroberflächen zu erstellen. Diese Programme können auf Plattformen wie Windows, Linux und Mac OS ausgeführt werden.

Mit Hilfe von Tkinter wurde für das Programm "3D-Baukasten" eine grafische Benutzeroberfläche erstellt. Die Oberfläche besteht aus einem Hauptfenster. In diesem Hauptfenster werden Buttons und Labels angezeigt. Es gibt Buttons für die einzelnen Bauteile und einen Button um das Programm zu beenden. Mit den Buttons für die Bauteile, ruft man deren Funktionen auf. In einem zweiten Fenster werden nun Eingabefenster und dazugehörige Labels angezeigt. In die Eingabefenster schreibt man die gewünschten Parameter. Um die STL-Datei zu erzeugen, drückt man den Button mit dem Namen des jeweiligen Bauteils. Dann wird die Datei im aktuellen Verzeichnis gespeichert. Auch im zweiten Fenster gibt es einen Button um das Programm zu beenden.

Erklärung der wichtigsten Funktionen in diesem Programm:

Das Hauptprogramm:

Zunächst werden hier die Bibliotheken/Module eingebunden

  • Tkinter as tk: Ermöglicht die Erstellung von grafischen Benutzeroberflächen
  • solid: Ermöglicht die Konstrucktion von 3D-Modellen mit Python
  • solid.utils: Ist ein Modul mit nützlichen Funktionen zur Konstruktion von 3D-Modellen. Es enthält z. B. Funktionen um Grundlegende Elemente wie einen Würfel oder Quader verschieben zu können:

up(): pos. z-Richtung, down(): neg. z-Richtung, left(): neg x-Richtung, right(): pos  x-Richtung, forward(): pos y-Richtung, back(): neg y-Richtung

  • os: Das os-Modul stellt eine allgemeine Betriebsfunktionalität zur Verfügung. Zugriffe auf Dateisysteme, auf andere Prozesse und Informationen über das Betriebssystem.
  • sys: Das sys-Modul ermöglicht den Zugriff auf Konstanten und Funktionen, die sich auf den Pythoninterpreter selbst beziehen.
import Tkinter as tk
from solid import *
from solid.utils import *
import os,sys

In vielen Tkinterprogrammen wird zunächst ein Hauptfenster erstellt, in dem man verschiedene "build-in" widgets platzieren kann. In diesem Fall wurde zuerst die Klasse MainWindow() erstellt.

class MainWindow(tk.Frame):
    
    def __init__(self, *args, **kwargs):
        tk.Frame.__init__(self, *args, **kwargs)
        self.master.title('3D-Baukasten')

Im ersten Abschnitt wird im Hauptfenster ein Frame Widget initialisiert und der Titel des Hauptfenster festgelegt. Danach werden die Labels und Buttons des Hauptfensters im Rahmen positioniert.

        self.w = tk.Label(self,text="Funktionen",bg="white",fg="black")
        self.w.grid(row=1,column=1,padx=5,pady=5)

        self.button1 = tk.Button(self,text="Wuerfel",command=self.create_window)
        self.button1.grid(row=2,column=1,padx=5,pady=5)
        
        self.button2 = tk.Button(self,text="Vierkant",command=self.create_window2)
        self.button2.grid(row=3,column=1,padx=5,pady=5)
        
        self.button3 = tk.Button(self,text='Strebe',command=self.create_window3)
        self.button3.grid(row=4,column=1,padx=5,pady=5)
        
        self.button4 = tk.Button(self,text='Winkel',command=self.create_window4)
        self.button4.grid(row=5,column=1,padx=5,pady=5)

Die Anordnung der Labels und Buttons erfolgt mit einem Geometriemanager. Hier wurde die grid()-Methode verwendet. Mit dieser Methode werden alle Labels und Buttons in einer Tabelle angeordnet.


Grundstrucktur der Bauteilfunktionen: Klickt man auf den Button "Strebe" so öffnet sich ein zweites Fenster. In diesem Fenster kann man die Parameter an die Funktion übergeben und eine STL-Datei erzeugen.

Die Funktion create_window erzeugt das zweite Fenster mit Eingabefenstern, Buttons und zugehöriger Beschriftung. In dieser Funktion wird zunächst ein Toplevel() Widget, mit dem Titel der Funktion erzeugt.

 

    def create_window(self):
        t = tk.Toplevel(self)
        t.wm_title("Name des Bauteils")
        
        

        def STL(entries):

#Hier wird die Funktion des Bauteils eingefügt.
#Die Funktion ist in Solid-Python geschrieben

            def Name der Funktion(entries):
                #Funktion die das Bauteil definiert
                return#Fertig zusammengesetztes Bauteil


            #Aufrufen der Funktion die den Solid-Python-Code generiert
            w = Name der Funktion(entries)

            #Erzeugen von Open-SCAD-Code aus Solid-Python-Code

            file_out = os.path.join( os.curdir, "Name der Datei mit Pyton-Code")

            #Umleitung des Openscad codes in eine Datei
            print scad_render_to_file( w, file_out, file_header='$fn = %s;'%SEGMENTS, include_orig_code=False)

            #Ausfuehren des Shell-Skripts um den Solidpython-Code in Open-Scad-Code umzuwandelt
            
            #Hier werden beliebige Argumente übergeben da die Funktion "os.execvp()"mindestens 
            #2 Argumente benötigt aber im Shell-Skript keine Übergabeparameter benötigt werden.
            args = (Zwei beliebige Argumente mit, getrennt)

            #Der Pfad muss an das Verzeichnis angepasst werden in dem sich das Skript befindet
            os.execvp("Pfad zum Shell-Skript",args)
            #Ende Programm

        #Funktion die die Eingabefelder mit Beschriftung definiert und entries zurueckgibt
        def makeform(t,fields):
            entries = {}
            for field in fields:
            #Erzeugt Ramen, Label, Eingabefeld
                tk.row = tk.Frame(t)
                tk.lab = tk.Label(tk.row, width=22, text=field+": ", anchor='w')
                tk.ent = tk.Entry(tk.row)
            #Fuegt in jedem Eingabefeld eine Null ein
                tk.ent.insert(0,"0")
            #Anordnung des Rahmens, Labels, Eingabefeldes
                
                
                
                tk.row.pack(side="top", fill="x", padx=5, pady=5)
                tk.lab.pack(side="left")
                tk.ent.pack(side="right", expand="yes", fill="x")
            #Erzeugt die Liste entries
                entries[field] = tk.ent
      
            return entries

        #Hauptteil der Funktion. Hier werden die Buttons und Funktionen aufgerufen

        ents = makeform(t,fields)
        root.bind('<Return>', (lambda event, e=ents: fetch(e)))
        b1 = tk.Button(t, text='Wuerfel',
           command=(lambda e=ents: STL(e)))
        b1.pack(side="left", padx=5, pady=5)
    
        b2 = tk.Button(t, text='Beenden', command=root.quit)
        b2.pack(side="left", padx=5, pady=5)

Der Hauptteil des Programms:

 

if __name__ == "__main__":
    root = tk.Tk()
    main = MainWindow(root)
    main.pack(side="top", fill="both", expand=True)
    root.mainloop()

 

Die erste Zeile sorgt dafür, dass das Pythonprogramm entweder als Modul oder als Stand-Alone-Programm dienen kann. Mit root = tk.Tk() wird ein root Widget erzeugt um Tkinter zu initialisieren. MainWindow(root) ruft die Klasse MainWindow im Hauptfenster auf. Mit der Pack()-Methode wird die Tabelle im Hauptfenster des Programms Angeordnet. Der Befehl root.mainloop() initialisiert die Hauptschleife.

Grafische Benutzeroberfläche:

 

Tutorials:

3. Programm um Bauteile zu erstellen

3.1 Solid Python

Solid Python ist eine Verallgemeinerte Form des Openscad moduls. Solid Python erzeugt aus Pythoncode einen gültigen Openscadcode.

Wichtige Openscadbefehle in Solid Python:

Die Befehle der Grundbausteine bleiben erhelten

2D-Objekte

circle(radius)

square(size,center); square([width,height], center)

polygon([points]); polygon([points], [path])

3D-Objekte

sphere(radius)

cube(size); cube([width,height,depth])

cylinder(h, r, center); cylinder(h, r1, r2, center)

polyhedron(points, triangles, convexity)

Die Befehle mit denen man die Grundbausteine verändern kann haben in Solid Python einen anderen Syntax

Transformations

In Solid Python ersetzt man translate([x,y,z]) mit:

Solid Python: right(10)()
Openscad:     translate(v=[10,0,0])

forward(10)() => translate(v=[0,10,0]                                                                                                 up(10)() => translate(v=[0,0,10])

Der Befehl rotate([x,y,z]):

Solid Python: x = rotate(a="grad", v=RIGHT_VEC)(cube([10,10,30]))                           Openscad:          rotate(a="grad", v=[1,0,0]) {cube(size=[10,10,30]);}

y = rotate(a="grad", v=FORWARD_VEC)(cube([10,10,30]))                                                rotate(a="grad", v=[0,1,0] { cube(size=[10,10,30]);}

z = rotate(a="grad",v=UP_VEC)(cube([10,10,30])                                                               rotate(a=90,v=[0,0,1]) {cube(size = [10, 10, 30]); }

Boolean operations:

union()()
difference()()                                                                                                                                intersecton()()

Achtung! Die geschweiften Klammern in Openscad müssen in Solid Python durch runde Klammern ersetzt werden!

Bsp:

Openscad: rotate([90,0,0]){ cylinder(h=4,r=2)}

Solid python: rotate(a=90,v=RIGHT_VEC)(cylinder(h=4,r=3))

Programm für ein neues Bauteil anpassen

Damit man die Werte die in der grafischen Oberfläche übergeben werden auch aufrufen kann benötigt man den Befehl:

float(entries['Name des Eintrags'].get())

um die Eingabefelder anpassen zukönnen muss man im Programm eine Liste erstellen.

Bsp.: fields = ('Breite', 'Hoehe', 'Tiefe')

Der dazu passende Befehl, um die Einträge aus der Liste aufzurufen lautet:

float(entries['Breite'].get())
float(entries['Hoehe'].get())                                                                                     float(entries['Tiefe'].get())

In der Funktion für das Bauteil muss in der Funktion makeform und im Haupteil noch der Name der Liste angepasst werden.

3.2 Bauteile

Winkel

Strebe

Strebe

Strebe mit zusätzlichem Loch(verschiebbar)

Lager

Lager

Ecke

3.3 Drucken mit PLA

PLA ist ein Biokunststoff. Er wird aus nachwachsenden Rohstoffen erzeugt. PLA kann unter bestimmten Bedingungen biologisch abgebaut werden. Da diese Bedingungen meist nur in industriellen Kompostieranlagen vorkommen, zersetzt sich der Kunststoff in der Natur nicht.


Änderungen, der Einstellungen am Slic3r:

Temperatur des Extruders: 200°C

Temperatur der Heizplatte: 60-70°C

Geschwindigkeitseinstellungen:

Perimeters: 30-40 mm/s

Small perimeters: 30 mm/s

External perimeters: 100%

Infill: 60-70 mm/s

Solid infill: 60-70 mm/s

Top solid infill: 40 mm/s

Support material: 60 mm/s

Bridges: 35 mm/s

Gap fill:  20 mm/s

Travel: 150 mm/s

First layer speed: 50 %

Bei Bauteilen mit dünnen Wänden langsamere Einstellung!!

Reprap doku: http://reprap.org/wiki/PLA