Manuel Odendahl_the happy abspack crowd

31. Oktober 2009 von Chris

Pasted Graphic 5(click the pix.) Im Januar 2009 führte ich einige Experimente mit meiner neu erworbenen CNC-Fräse durch. Eine CNC-Fräse ist eine normale Fräse (in diesem Fall eine Oberkopfportalfräse), die allerdings nicht manuell, sondern von einem Computer gesteuert wird. (pix_1)

Bei meinen ersten Versuchen wurden Löcher gebohrt, Quadrate geschnitten und einfache Schriftzüge graviert. Recht schnell wurde allerdings klar, dass der Ansatz existierender CAD- (zum Entwerfen von Objekten) und CAM-Software (zur Umwandlung des Entwurfs zu einer Folge von Maschinenbefehlen, die die Fräse ausführen kann) nicht wirklich meinem Umgang mit Technik entsprach, weil sie entweder vom Workflow sehr limitiert waren (keine Skriptmöglichkeiten z.B.) oder so hochprofessionell, dass die Einarbeitungszeit eher einem Maschinenbaustudium entsprach. In solchen Fällen zögere ich nie lange, und so beschloss ich, meine eigene CAD- und CAM-Software zu schreiben, am besten noch in Common Lisp, einer recht obskuren und sagenumwobenen Sprache ( http://de.wikipedia.org/wiki/Common_Lisp ). Eine (intensive) Woche später war diese Software in einem brauchbaren Zustand (zu bewundern auf http://cl-mill.googlecode.com/ , der Programmcode ist nur unter dem Einfluss von mittelstarken Alkoholika zu ertragen), samt Bitmaptracing, Kurvenoffsetberechnung, Jobmanagement und Platinenlayoutimport. (pix_2)

Das erste eigentliche CNC-Projekt für diese Software war das Fräsen einzelner Holzbretter, auf die eine USB-MIDI-Kontroller Entwicklungsplatine fixiert werden sollte. Der riesige Vorteil bei dem Einsatz von »offener« Software (in dem Sinne, dass der Programmquellcode erstens erhältlich ist, und zweitens auch malleabel, also einfach genug zu modifizieren und erweitern) ist, dass dadurch generative Ansätze möglich werden. Z.B. der Ansatz, jedes Holzbrett für jede einzelne Entwicklungsplatine anders zu gestalten und zu fräsen, ohne dass der Aufwand für den Entwickler/Designer/Maschinenoperator besonders wächst. Bei diesem konkreten Projekt werden auf der Oberseite jedes Brettes drei tanzende Männchen gefräst, so dass aus jedem einzelnen Board ein Unikat wurde. (pix_3)

Zum Ausprobieren von grafischen und generativen Ideen ist die Processing-Umgebung, die unter http://processing.org/ zu finden ist, nahezu ideal. Ähnlich zu den BASIC-Interpretern (http://de.wikipedia.org/wiki/BASIC) auf früheren Heimcomputern, oder zu der LOGO-Schildkröte (http://de.wikipedia.org/wiki/Logo_(Programmiersprache), bietet Processing die ideale Spielwiese für kleine Programmschnipsel und eine sehr inspirierende Lernumgebung. Die tanzenden Männchen sollten von einem Processing-Programm erzeugt werden, um anschließend von der CAM-Software zu einem Brett zusammengestellt werden. Jedes Monster besitzt zwei Arme, einen Körper und zwei Augen. Um jedes Monster anders zu gestalten, müssen diese Elemente verändert werden. Für die Augen bieten sich Ellipsen an, deren Position und Form variiert wird. Für den Körper und die Arme werden Bézier-Kurven eingesetzt (diese Kurven werden von zwei Anfangspunkten und zwei Kontrollpunkten bestimmt, die interessante Krümmungen erzeugen). Es müssen also die Anfangspunkte und Kontrollpunkte von drei Bézier-Kurven berechnet werden, sowie die Position und Form von zwei Ellipsen. Insgesamt also 32 verschiedene Zahlen, die natürlich nicht komplett zufällig sein dürfen. Der linke Kontrollpunkt des Körpers z.B. befindet sich auf einer Gerade, die im Winkel von 60 bis 90 Grad zur Horizontale steht. Je kleiner der Winkel, desto spitzer die linke Seite des Männchens. Mit ähnlichen Überlegungen wurde die Formeln für die restlichen Glieder erzeugt. (pix_Quellcode + pix_4)

Der erste Versuch sah dann ungefähr so aus: http://bl0rg.net/~manuel/yay-mon/maennchen.pde (code), http://bl0rg.net/~manuel/yay-mon/ (applet). Ganz optimal ist das Programm noch nicht, erlaubt aber die Visualisierung und die Anpassung der Generierungsparameter. Im nächsten Ansatz wird noch die Dicke der Arme und Augen durch einen breiteren Pinsel kontrolliert, und zum Spaß werden ganz viele Männchen zu einer jubelnden Menge zusammengestellt: http://bl0rg.net/~manuel/abspack-crowd/maennchen.pde http://bl0rg.net/~manuel/abspack-crowd/maennchenclass.pde (code) http://bl0rg.net/~manuel/abspack-crowd/ (applet). So wie eine Bleistiftskizze, sind bei dem Programmcode hier die Entstehungsschritte und Radierungen und Ergänzungen sichtbar. (pix_5)

Nach dem Erfolg dieser virtuellen Experimente mit Processing war es nur noch ein schnelles Schieben von Bits und Bytes, bis die CNC-Fräse dank Schrittmotoren die Brücke zwischen virtueller und harter Welt herstellen konnte. (pix_6 + pix_7)

interview part I | II
wesen sounzzz
ruin&wesen

english version
January 2009 was a month of experimentation with my newly acquired CNC mill. A CNC mill is like a normal mill, except that the position of the milling head (or the piece of material, depending on the mill design) is controlled by a computer. (pix_1)

My first tests were of course drilling holes, milling out squares and engraving simple texts and designs. I quickly became aware that conventional approaches to CAD (designing objects) and CAM (converting the design into a sequence of machining steps) did not really suit my development style: either they were quite limited workflow-wise (no scripting for example, which is something I swear by), or highly specialized (and expensive) pieces of professional software requiring a degree in engineering. In cases like these, I usually don’t hesitate long and reinvent the wheel by writing my own software (don’t try this at home, of course). In this case, I wrote a »programmable« environment for generating G-Code (the machine language telling the mill how to move its head). The software was written in Common Lisp, a quite obscure and very expressive language, that in my hands usually ends up in writing chaotic software. A (very intense) week later, I had written a pretty functional software (which you can get at http://cl-mill.googlecode.com, the sourcecode kind of reflects the way it was written though). It features bitmap tracing, offset milling curves, job management and importing PCB-layout files. (pix_2)

The first »real« project for the whole CNC contraption was milling small wooden boards to help mount prototype PCBs for a USB-MIDI-Controller. The biggest advantage of having an »open« program (in the sense that you can get, modify and extend the sourcecode) is that it is easy to use generative approaches (in which part of the design is actually created by an algorithm). The idea for the prototype controller was to have a different wooden board for each PCB, without increasing the design and production workload too much. In this project, I came up with the idea to have dancing people on top of the board. Each board would have a few different creatures on top. (pix_3)

A very nice software to try out graphical and generative ideas is the Processing-environment, that can be downloaded at http://processing.org/ . It is similar to older BASIC-interpreters that would run on older homecomputers, or to the LOGO programming language (yes, the turtle). Processing gives you an ideal playground to try out small »sketches« of software, and provides for rapid feedback: enter the code, press run, modify the code, press run again, etc… The small dancing creatures are generated by a processing sketch, and are converted by the CNC software to actually make a wooden board (with holes for screws, a logo and a serial number). Each creature has two arms, a body and two eyes. To make each creature unique, these elements have to be varied in size and shape (that is, the parameters controlling the geometrical objects behind these elements have to be varied). The eyes are made out of two ellipses, of which the size and position can be modified (however, the ellipse itself is restricted to a certain area of the body, so that one eye doesn’t up on the arms of the creature, or outside its head). The body and the arms are made out of bezier splines (bezier splines are controlled by a starting point, an end point, and two control points that determine their curvature). Thus, we need to generate 8 control values for each spline, and 4 values for each eye. The whole creature is thus described by 32 values that are in specific relations to each other. For example, the first control point of the body spline is situated at a 60 to 90 degree angle left-upward from the starting point. Similar thinking hides behind the calculations for the other parameters of the creature. (pix_Quellcode + pix_4)

The first tries at generating a creature can be seen in the black image above. http://bl0rg.net/~manuel/yay-mon/maennchen.pde (code), http://bl0rg.net/~manuel/yay-mon/ (applet) The program is not yet quite finished: the shape of the creature makes it impossible to mill. However it is quite useful to see which parameters need to be adjusted. In the next try, the width of the arms was made bigger, and a lot of creatures were put together to create a dancing crowd. http://bl0rg.net/~manuel/abspack-crowd/maennchen.pde http://bl0rg.net/~manuel/abspack-crowd/maennchenclass.pde (code) http://bl0rg.net/~manuel/abspack-crowd/ (applet) As with a pencil sketch, the code shows the different steps of its creation. (pix_5)

Declaring this second test a success, it was just a matter of writing a few more program lines to convert the image of the creatures to G-Code that would be interpreted by the CNC mill, linking the real world to a digital idea. (pix_6 + pix_7)

wesen sounzzz
ruin&wesen

FacebookTwitterGoogle+