Ressourcen & Tutorials

Hauke Sandhaus 116222 HCI / Tim Vischer 116103 MKG

Schritt 1: Auswahlverfahren

Zu Beginn stand die Entscheidung was entstehen soll während des Fachkurses. Die Auswahl traf schnell auf eine Kombi aus CNC Fräse und Lasercutter.

Schritt 2: Planung der Herangehensweise

Nachdem die Auswahl getroffen war stand die Frage offen nach dem System was wir nutzen wollen um zu einem Ergebnis zu gelangen.

Wir verglichen Preise und Aufwand von Fertigbausatzimporten aus China mit DIY Varianten aus dem Internet als auch ein kompletter Eigenbau wurde mit in Erwägung gezogen. 

https://docs.google.com/spreadsheets/d/1AOQIUSOdYe_7U4DtAUrVloRAr9x3YzqgaUnFOTiiMjM/edit?usp=drive_web

Wir kamen zum Schluss das wir gerne einen größeren Eigenanteil an Gestaltung und Aufbau der Maschine haben möchten jedoch nicht den zeitlichen Aufwand eines kompletten Eigenbaus einschätzen können, daher fiel die Wahl darauf der Anleitung zum “Mostly Printed CNC” zu folgen.

Zur Entscheidung hat außerdem beigetragen dass sich mittlerweile eine größere Community um den Entwurf von “Vicious1” (https://www.vicious1.com) gebildet hatte, welche die spätere Einrichtung und eventuelles Troubleshooting erleichtert.

Der voraussichtliche Endaufbau soll diese Form annehmen:

Schritt 3: Bestellliste

Wir entschieden uns gegen das Fertigpaket welches vom Entwickler zum kauf angeboten wurde und planten aufgrund der angegebenen Ressourcen eine Bestellliste der nicht geprinteten Teile.

(https://docs.google.com/spreadsheets/d/13U8QZNeTh46jVMGOoRa-_YoFNEZlD4dErIkCerJOpc4/edit#gid=0)

Bis auf Teile bei denen die maße der 3D geprinteten Teile eine Rolle spielt ( Gestänge, Schrauben und Muttern) wurden über die letzten zwei wochen alle Komponenten geliefert.

Schritt 4: Printen

Es wurde eine Tabelle aller zu fertigenden Teile zusammengestellt und danach ging der lange Prozess des Printens los.

(https://docs.google.com/spreadsheets/d/1l4tSlmt_Li28TUgpbqE89Z9fhLXW8cEAZy3rZytoxr0/edit#gid=0)

Vorerst auf einem Ultimaker2 der MKG der nach einer lange phase des Einrichtens einigermaßen gute Ergebnisse liefert jedoch auch viele fehlgeschlagene Prints zwischendurch produziert.

Fehlschläge:

Verwendbare Prints:

Schritt 4.2: Anschaffung Anet A8

Nachdem der Ultimaker2 sich qua Printqualität als nicht berechenbar herausstellte schafften wir uns nach einigen vergleichen mit dem Prusa nachbau den Anet A8 an und richteten ihn ein.

Erste Ergebnisse:

4.3 Zwischenstand:

Weitergehend werden wir jetzt den Anat A8 so einrichten dass er eine sehr gute Printqualität erreicht indem wir einige der günstiger produzierten Teile austauschen und neu Printen.

Hierzu zählen die Anschaffung von besseren Filament, einer Glasplatte für das Heatbed, eine bessere Materialzuleitung, Lüftung und Gleitlager anstelle der mitgelieferten Kugellager.

5. Der Aufbau:

Nachdem wir die Stahlrohre auf Länge gebracht (mit hilfe des auf der Website befindlichen Calculators) und eine Holzplatte zugeschnitten haben, können wir den Aufbau zusammenschrauben.

Das letzte und etwas schwierigere war das finden der passenden Schrauben. Da alle 3D druck Teile imperiale maße besitzen mussten wir teilweise kleinere und größere Schrauben erwerben und die Löcher aufbohren. Ein ankauf von Spezialschrauben wäre zu teuer gewesen und auch metrische Einzelschrauben zu erwerben gestaltete sich schwierig. Die in Weimar verorteten Baumärkte Obi und Toom verkaufen nur in großen Packungen was zu unkosten von hochgerechnet 60-70 € geführt hätten. Durch Recherche landeten wir bei Hornbach in Jena, welche Einzelschrauben verkaufen, wir kamen mit einem Betrag von 20 € für alle Schrauben heraus mussten jedoch einige Schrauben kürzen und Mutternköpfe entfernen.

Nachdem wir alle Teile erworben haben bauten wir nun zusammen. Insgesamt hat der zusammenbau gute zwei Tage in Anspruch genommen. Beim zusammenbau selbst musste trotz aufgebohrter Löcher noch einiges an Gewalt angewendet werden was zum zerbersten einiger Teile geführt hat, diese hätten aber demnach auch nicht lange im Betrieb stand gehalten. Der Aufbau selbst ist auf der Website gut dokumentiert auch wenn einiges an umdenken gefordert wird.

6. Endergebnis zur summaery:

Zur summaery im Juli präsentierten wir den fertigen Aufbau innerhalb der Kursausstellung mit einem Pen-Plotter zum bearbeiten der Arbeitsfläche.

Ausstehend:

Nachdem der Mechanische Aufbau komplettiert ist fehlt noch das anbringen der Motoren und die Verkabelung dieser. Danach muss nur noch das Driverboard welches auf Marlin laufen soll geflasht und initialisiert werden.

Ebenfalls müssen wir noch einen Fräßkopf erwerben.

IIP Mini Select:

Beim kleinen Drucker ganz wichtig, der End-Gcode (d.h.) nach erfolgreichem Druck:

Das Filament per Gcode _nicht_ weiter als 2-3 mm zurück in die Düse ziehen, oder gar nicht.

Dann per Gcode _zuerst_ das Heizelement abschalten und den Lüfter noch einige Minuten nachlaufen lassen. Sonst verstopft das Hotend.

Ansonsten ist der kleine ziemlich stressfrei. Ggf. vor dem Druck noch einen Tropfen Öl (am besten Ballistol, zur not Rapsöl) auf den kleinen Schwamm (“Filament Filter”) oben am Extruder geben, dann flutscht alles besser. Der Extrudermotor ist etwas schwach.

ShaperCube:

Über den 3er-Verteiler hinter dem Shapercube anschalten.

Das Heizbett am Shapercube ist momentan nicht gesteuert sondern einfach immer voll an. Also Achtung heiß. Wenn ihr ohne Heizbett drucken wollt dann müsst ihr den Netzstecker aus dem Netzteil was der Heizplatte Strom liefert rausziehen. Anschließend bitte wieder einstecken, damit der nächste…

Beim Start eines Druckes könnt ihr durch leichtes ziehen am Riemen für die Z-Achse eine feine Höheneinstellung für die erste Schicht vornehmen. Die Richtung findet ihr raus indem ihr den Drucker beim hoch und runterfahren vor Druckbeginn beobachtet.

Prusa Clone:

Da solltet ihr vor allem aufpassen euch keinen Stromschlag an den Netzteilen zu holen. Da sind die 230V Anschlüsse am Netzteil relativ ungeschützt, also Vorsicht. Ansonsten funktionieren die recht zuverlässig.

Delays are bad
Probably the first Arduino sketch you’ve seen is the ‘blink’ sketch. It’s a nice and short piece of code to explain the basic workings of Arduino without scaring you with loads of new things to learn. Unfortunately in terms of everything else, especially user interaction, it’s absolutely terrible. The culprits are these two lines:

delay(1000); and
delay(1000);

If you’ve played some amount of video games in your lifetime, you probably know what FPS (frames per second) are and what influence they have on user interaction. They indicate how many times a second your button presses are checked and the action on screen is updated. So, what’s a desirable number of FPS?

• 60 FPS and above: Perfectly fluent interaction. Very fun.
• 30 FPS: Still very fun, but noticeable differences to 60FPS.
• 20 FPS: Playable, but no fun at all.
• Under 20 FPS: Agony.

While the responsiveness of games is measured in FPS, the responsiveness of Arduino Code should be measured in LPS, aka how many times the loop section of your code is completed in one second. So, how many LPS does the blink sketch have?

• 0.5 LPS. That’s bad.

If we want to fit at least 60 loops into one second, the entire delay time in the sketch should not exceed 16ms. Delay() is not a great tool for timing, so we need something different.

Introducing millis()
The blink sketch has no user interaction at all, so it’s not really an exciting example for this tutorial. Instead, we are going to code the most useless lamp ever created: One that turns itself off exactly one second after it was turned on. You’ll need a button, a led and any Arduino board.

Pretty much all we are going to do revolves around one new Arduino function: millis(). So what does it do?Inside every Arduino, there’s a little counter that simply counts the milliseconds since the Arduino has been turned on. With millis() we can retrieve the current amount of milliseconds and save them in a variable.

A word on ‘unsigned long’: Maybe you’re wondering, why we don’t use the traditional ‘int’ to initialize our variable. An int cannot contain an infinitely large number, it only covers an area from around -32000 to +32000. Since were measuring time in milliseconds and time only marches forward, we can only fit 32 seconds into one int. ‘Unsigned long’ on the other hand goes from 0 to around 4.3 billion or nearly 50 days in milliseconds. So we’re a lot more flexible in terms of timing.

Let’s go back to our useless lamp and look at it on the timeline. At some point in time the button will be pressed and the light will turn on. We’ll call this the ‘Trigger-Event’. Then, exactly 1000ms later, the lamp will be turned off again. We’ll call this the ‘Response Event’.

The Trigger Event
Let’s focus on the trigger event first. If the button is pressed, we should do two things:
1. Turn the led on
2. Save the time the event occurred in another variable.
In code, it looks like this:

The response event
The response event itself is pretty simple: Just turn the led off. But we need to define very specifically when this event should occur. We want the Response to happen exactly one second after the Trigger. We only have the current time and the last time a Trigger-Event happened to work with. So this is what we do:

1. We need to know how much time has passed since the last Trigger, so we subtract our Trigger-Time from our Current Time.
2. We need to know if enough time has passed for the Response to happen, so we check if the time passed is bigger than 1000ms
In Code, it looks like this:

And that’s it. Exactly one second after each Trigger Event, the Response Event happens. Our useless lamp is complete and we’ve learned the fundamental technique to get rid of delays in your code.

To recap
1. There are always two events, we need to code.
2. In the Trigger event we need to save the time it happened.
3. For the Response Event we compare the current time minus the saved time to our delay time.

19.07.16 / 12-17 Uhr / Open Process Lab (M1b, 2. Etage)
Max. 16 Teilnehmer

Möglichst eigenen Laptop, Maus und die neueste Blender Version mitbringen.

Tutoren: Sebastian Lotz & Christopher Kopic
Anmeldung per Email an Sebastian.Lotz@uni-weimar.de

Blender ist Open Source Software und kann somit kostenlos und legal hier heruntergeladen werden: blender.org

Wir wollen einerseits einen Überblick über alle wichtigen Funktionen von Blender geben, andererseits auf einige Kernbereiche besonders eingehen. Wir erhoffen uns damit, dass die Teilnehmer nach Ende des Workshops in der Lage sind kleine Projekte selbstständig zu lösen und für größere Projekte besser nach Tutorials suchen können.

Zum Erreichen dieser Ziele soll jeder Themenabschnitt zur Übersicht kurz präsentiert werden. Wichtigere Themen (fett gedruckt) werden dann direkt im Anschluss mit praktischen Aufgaben vertieft. So können auch Inhalte zur Sprache kommen,  wie z.B. Modelliermethoden für den 3D-Druck, für die das letzte mal keine Zeit blieb. Jeder Themenabschnitt wird mit einer Beispieldatei und weiterführenden Online-Tutorials ausgestattet sein.

1. Einführung in die Nutzeroberfläche (45min)
2. Modelling (1,5h)
   1. Einfaches Modellieren
   2. Modifier
   3. Boolen
   4. Subdivision Modelling
   5. Sculpting
   6. Modellieren für 3D Druck
3. Rendering (1,5h)
   1. Szene (Hohlkehle)
   2. Licht
   3. Materialien und PBR
   4. Texturen
   5. Rendering
   6. Compositing

Die Software Blender ist umfangreiches Werkzeug zur Erstellung und Verarbeitung von 3D-Inhalten. Das Programm ähnelt in Leistung und Funktion anderen Produkten wie Cinema 4D oder 3ds Max ist aber im Vergleich zu diesen Open-Source und daher kostenfrei legal nutzbar. Die daraus entstandene Community und eine Vielzahl von Tutorials und PlugIns dienen als umfangreiche Wissensbasis, um den Hürden bei der Umsetzung eigener 3D-Projekte erfolgreich zu begegnen. Dem Designer kann diese Software zunächst vor allem als Konstruktions- und Formfindungswerkzeug dienen, welches im Vergleich zu ‚richtigen‘ CAD-Programmen schnelleres Arbeiten mit höherer künstlerischer Freiheit ermöglicht. Aus den so entstandenen Modellen lassen sich „wasserdichte“ Konstruktionen für den 3D-Druck erstellen. Des weiteren können Meshmodelle wieder in herkömmliche CAD-Software übertragen werden, um Vorlage für ein endgültiges Nurbsmodell zu sein. Der eigentliche Zweck von Blender ist das Rendern und das Animieren. Damit hat der Designer umfangreiche Möglichkeiten Ideen, Prozess und Produkte in Szene zu setzen und zu kommunizieren. Die Renderengine ist dabei in der Lage sowohl fotorealistische Ergebnisse zu liefern, die anderen Renderprogrammen wie VRay oder Keyshot in nichts nachstehen, ermöglicht aber auch abstraktere Stile, beispielsweise für Infografiken.

Warum zur Hölle sollte man denn um Arduino zu lernen Processing lernen anstatt Arduino zu lernen?

Dieser Ansatz ist ein Vorschlag, der mir sehr geholfen hat, mich erfolgreich an Arduino ranzutasten, ich möchte erklären wieso:

Wer Arduino lernen will findet dafür jede Menge guter Tutorials im Netz (Getting Started: Arduino), da es aber beim Arduino darum geht Dinge selbst entwickeln zu können wird man früher oder später an den Punkt gelangen sich außerhalb der  vorgefundenen Tutorials zu bewegen. Dafür hat man dann mehrere Möglichkeiten. Zum einen kann man verschiedene Tutorialbestandteile zusammen packen und hoffen dass es klappt, oder man versucht zu verstehen, wie das alles funktioniert.

Um mit einem Arduino Umzugehen muss man sich mit 3 unterschiedlichen Dingen befassen:

Elektrotechnik (Zeug zusammenlöten, Bauteile auswählen)

Installation und Management von Software und Hardwaretreibern

Programmierung

Um nun wirklich unabhängig Arbeiten zu können sollte man alle Teilbereiche in groben Zügen verstehen.

Aber warum zur Hölle sollte man nun Processing lernen, wenn man doch Arduino lernen will?

Processing befasst sich erstmal nur mit Programmierung und Arduino mit Programmierung UND Elektrotechnik.

Wenn ich also ein Arduinoprojekt zusammenwurstle und dann funktioniert es nicht, dann weiß ich erstmal nicht woran das liegen kann. Nun gibt es bei der Fehleranalyse ein unschlagbares Prinzip: das Ausschlussverfahren; Alles voneinander zu isolieren um herauszufinden wo genau das Problem liegt. Man stelle sich vor: Mein Stuhl wackelt, aber warum? Ist es der Stuhl oder der Boden? Nun kann ich den Stuhl nehmen und ihn auf eine Fläche stellen, von der ich sicher weiß, dass sie eben ist. Wackelt er dort nicht, weiß ich, es muss der Boden sein. Genau so kann ich mit meinem Arduinoprojekt verfahren. Wenn die LED, die ich angeschlossen habe einfach nicht zum Rhytmus der Musik blinkt, kann es sein, dass die LED kaputt ist, oder meine Verdrahtung ist falsch, meine Lötstellen sind kaputt, oder ich habe einfach Quatsch programmiert. Also, LED austauschen, alles nochmal Löten. Geht immer noch nicht? Vielleicht ist die neue LED auch kaputt? Oder ist mein Arduino nicht richtig angeschlossen? Oder doch die Programmierung? Wie könnte ich die Programmierung überprüfen ohne einen mit Sicherheit funktionierenden Hardwareaufbau zu haben?

Aha! Indem ich mir eine Programmierumgebung suche, die mir direkt Feedback innerhalb der Software gibt!

Und genau da kommt Processing ins Spiel. Processing ist eine Programmiersprache, die für einfaches Erlernen ausgelegt ist und dafür optimiert ist visuellen Output zu generieren. Und das schöne ist, Processing und Arduino sind Geschwister. Die Prinzipien sind gleich, der Programmablauf ist gleich und die Grundfunktionen sind dieselben. Unterschiede bestehen zwar, allerdings sind diese logisch einfach nachvollziehbar und zum Programmieren lernen erstmal vernachlässigbar.

Schauen wir uns die beiden Umgebungen einmal an sehen wir schnell, dass beide sehr ähnlich aussehen. Die Hauptunterschiede sind, dass man bei Arduino void loop() schreibt und in Processing void draw(), was aber für den Programmablauf genau dasselbe bedeutet. Der zweite wichtige Unterschied ist, dass man bei Arduino einen Upload Button hat und bei Processing einen Play Button. Beide haben eine ähnliche Funktion. Arduino lädt das Programm auf das angeschlossene Board, Processing startet das geschriebene Programm.

In Processing gibt es zusätzlich zu den Grundfunktionen ein paar einfache Möglichkeiten visuellen Output zu generieren. Zum Beispiel würde die Zeile

rect(20,20,40,40);

folgende Ausgabe produzieren:

Somit sind wir in der Lage unseren LED-Blinke Code zu überprüfen in dem wir anstatt eine LED an und auszuschalten einfach ein Rechteck blinken lassen. Wenn das funktioniert ist die Programmierung korrekt, kann zurück übertragen werden und wir wissen, dass irgendetwas mit unserem Hardware Setup nicht stimmt. Natürlich wird dieses Vorgehen umso nützlicher, je komplexer die Programmierung ist, die unser Projekt benötigt.

Darüber hinaus lassen sich Prinzipien wie if-Abfragen, for-Schleifen und viele weitere grundlegende Programmier-Prinzipien sehr leicht mit Processing verstehen und erlernen, weil man sich hier wieder auf die Prinzipien selbst konzentrieren kann und nicht mit Löten und Breadboarden beschäftigt ist. Hinzu kommt noch, dass Processing selbst natürlich auch unabhängig von Arduino genutzt werden kann um Muster als Vorlagen für Lasercutten zu generieren, oder um damit die Daten anzeigen zu lassen, die mein Arduinosensor sammelt, oder direkt mit Grasshopper interagieren kann um fancypants-3D Daten zu erstellen, oder, oder, oder.

Und um Processing zu lernen gibt es Unmengen an Tutorials, z.B. die von Daniel Schiffman, dem hinreißendsten Nerd der Welt:

http://hello.processing.org/

Oder natürlich den Processing Tutor, der jeden Mittwoch von 16:30 bis 18:30 im OPL sitzt und momentan seine Zeit damit verbringt Blogeinträge zu schreiben, weil niemand da ist 😉