Main steps to create a resin mould-resin object.

Drawing:
The object would contain a surface with texture, an extrussion or a pattern. It would  represent a mathematical shape as a interesting effect. Rhinoceros programme would convert it in a fast way.
*www.formx.es
*www.erwinhawer.com
*www.mathworld.wolfram.com

Mould/mold:
I would work with two shapes: a positive shape box and a negative shape object.

Machine milling:
The firts step would cheak materials you would engrave as well clear measurements for tools. In this way RhinoCAM would  simulate the exact milling motion before the machine would  start milling. A 12 mm lead and 3mm lead would be necessary to finish this mold. In other way, 14 hours would be necessary for milling before start.

Clean the box:
It would be an easy task using the air cleaner machine.

Lighting LEDs area:
I would  use a 12cm LEDs. It would be necessary to weld some parts as two metallic wires. In the same way I would  test the LEDs before using as well as I would  keep testing after every step you finish. I would  keep a battery in hand for necessary testings.

SmoothCast 327:
It would to use in several seals as would to dry in 2-4 hours.
*liquid vasilin
*gloves
*masks

Pour out the resin:
The resin would pour out the box. Now I would  wait for the right time to open it, 14h.

To clean the shape:
The negative shape would be the lighting shape.

I designed and fabricated a lamp using molding and resin casting. I’m sharing my experiences here: this is a step by step documentation of whole process. Along the way I’ll point out what I did well and where I made a mistake. Enjoy.

If you’re not that familiar with the hole digital fabrication project, then I recommend reading Neil Gershenfeld’s article where he explain why it’s important and where it’s heading.

The best resource for more info on these techniques is the Guerrilla guide to CNC machining, mold making, and resin casting.

1. Concept

I didn’t have very elaborated concept for this project. It was mainly an exploration of techniques. There were lots of things that were new for me here:

• designing 3D, physical objects
• a CNC machine
• milling a mold
• resin casting

My basic idea was a spherical object with lights in the center. In hindsight it turned out well that I didn’t spend that much time on perfecting concept and design, because the process involves many steps, and in each phase decisions have to be taken that influence the final outcome. My advice to those getting started with similar project would be to start with a simple idea and proceed fast from there, trying out different techniques and materials in the process. These are powerful techniques, but don’t expect to get the exact result you have in mind for your first project. Be prepared to improvise. Also be aware that this whole process took a couple of days to complete. Don’t expect to do this in one afternoon if you haven’t done it before.

2. Design

This project also was an excuse to try out He_Mesh, a Processing library by Frederik Vanhoutte. The He in He_Mesh stands for Half-Edge data structure, which is one of the many ways to store information about a mesh. I didn’t go to deep in the underlying logic because it seems rather esoteric knowledge. From what I understand, this is an computationally efficient way to work with meshes, enabling us to do all kinds of interesting manipulations without having to worry about how things work behind the scenes.

Here are a few interesting projects that make use of He_Mesh:

• Matthew Plummer-Fernandez is interested in remixing everyday objects and cultural icons such as Mickey Mouse. He raises all kinds of interesting questions related to originality and copyrights.
• HemeshGui is a graphical interface for He_Mesh, meaning you can experiment without writing code. It doesn’t expose all of the features of the library, but it is a good way to get a feeling for its possibilities. HemeshGui doesn’t seem the work perfectly with the latest He_Mesh version, but I’ve opened an issue with a possible solution.
• easySunflow is a software written in Processing that can used to create high quality images of He_Mesh objects with the Sunflow renderer.

It can be a bit hard to get started with He_Mesh, so here is what I recommend:

• Install HemeshGui and experiment with the parameters.
• Start with Jan Vantomme’s excellent introductory series of blog posts.
• Have a look at the tutorial folder in the library, especially the 1-4 are a good general intro.
• Then it’s best to start playing around. If you get stuck, head for the reference folder in the distribution and check the Java docs in the doc folder.

I created a Github repository for the Processing source code. The code is short and simple to understand. It feels very similar to what you would do in a 3D software package. These are the basic steps in a He_Mesh program:

1. Creating a mesh using a ‘creator’. This can be a geometric primitive such as a box or a sphere, or something more complex like a torus. Or you can provide it a list of vertices.
2. Manipulating the mesh with ‘modifiers’ and ‘subdividors’. Examples include: skewing, smoothing, slicing, and so on.
3. Rendering and/or saving.

Let’s see how that applies to my case. I started from a sphere:


HEC_Sphere creator = new HEC_Sphere();
creator.setRadius(200);
creator.setUFacets(16);
creator.setVFacets(16);
HE_Mesh = new HE_Mesh(creator);


Note that we set a few options, such as the radius and the number facets. Here is how that looks:

Then I applied the extrude modifier:


HEM_Extrude extrude = new HEM_Extrude();
extrude.setDistance(50);
extrude.setRelative(false);
extrude.setChamfer(5);
mesh.modify(extrude);


The chamfer option cuts of the edges of the extruded faces. I’ve disabled relative here, so the number 5 for the chamfer is absolute, not relative to the face size. This is the result:

Modifiers can be chained together. Here’s how we apply the bend modifier to the extrusions:


HEM_Bend bend = new HEM_Bend();
P = new WB_Plane(0, 0, 0, 0, 0, 1);
bend.setGroundPlane(P);
L = new WB_Line(0, 0, 1, 0, 0, -1);
bend.setBendAxis(L);
bend.setAngleFactor(0.25);
bend.setPosOnly(false);
mesh.modify(bend);


This one is a bit more complicated, because He_Mesh gives us a lot of control over how we bend the mesh. We need to give this modifier a plane. I’ve used the XY plane here. The part of the mesh that will be above the ground plane will be bent in one way, and what is under it in the other direction. We also have to specify the axis around which we will bend, which is the Z-axis here. The following image should make it more clear:

The angle factor determines how much bending is applied. I’ve disabled ‘positive only’ because I also want the modifier to be applied on the negative side, which is the part of the sphere under the ground plane.

And finally, I applied the Catmull-Clark subdividor, which smoothens the extrusions. This is the code:


HES_CatmullClark catmullClark = new HES_CatmullClark();
mesh.subdivide(catmullClark);


And this is the result:

Rendering can be done like this:


WB_Render render = render = new WB_Render(this);

noFill();
stroke(10);
render.drawEdges(mesh);


Exporting to a OBJ format is simple:


HET_Export.saveToOBJ(mesh, sketchPath("lamp.obj"));


3. Preparing the mold

This part of the process is largely depends on the Rhino 3D package. I wasn’t familiar with it, so it took me some time to get used to it. I also wouldn’t have made without the help from skilled people like Anastasia, Moushira and Martin. Thank you!

If you haven’t used Rhino before, I’d suggest taking a few hours to get comfortable with the software. The most important things to understand for projects like these are:

• Using the Rhino command line
• Moving around
• Making selections
• Showing and hiding objects
• Drawing primitives
• Positioning objects
• Boolean operations

For me this dependency on relatively expensive piece of software is a bit strange. I’m also not such a big fan of the interface, it feels kind of awkward and 90s. It would interesting to see if this part of the process can be done with cheaper/nicer/open-source tools. There’s two main reasons to use Rhino:

1. Boolean operations. I couldn’t find a way to do this with Processing, but Frederik mentions that he plans to support this in He_Mesh. That would be awesome because that would mean that one more step of the process could be automated.
2. Preparing the instructions for the CNC machine. This is actually not handled by Rhino itself, but by a very expensive plugin. I can’t imagine that it wouldn’t be that easy to find a replacement for that tool.

Rhino is also still mostly a Windows affair. I’ve used the Mac beta (of September 2012), which seems to work well. It is available for free as long until the final release version will come out, which is unknown at this time. Biggest disadvantage is that most plugins don’t work, including the one we used to create the instructions for the milling machine.

But why do we need a 3D package anyway? Can’t we just send the file to a machine as it is and have it figure out what to do with it? We should actually take a step back here and look at what we want to do. We’re going to create a mold here, which we will fill with resin later. The mold consists of two halves that form a box together. Here’s how we modelled that box in Rhino:

Then we imported the OBJ output of the Processing sketch. Using Rhino’s boolean tools, we hollowed out the surface of the lamp from the box. The trick here is to make sure that the box and the object you want to make are of the same type. 3D software packages either prefer meshes (like Rhino) or solids (like Maya). The difference has to with the way a 3D geometry is stored. Since we drew the box in Rhino, it’s a mesh. The imported OBJ file is a mesh. If you want the boolean operation to succeed, both should be of the same type. We converted the box to a solid with the MeshtoNURB command. Then both the lamp and the box can be selected and the BooleanIntersection command can be applied. Here is a screenshot of one half of the box:

4. Fabricating the mold

Then it’s time to create the instructions for the CNC machine. I did this project at the FabLab Barcelona, where we have a Precix machine:

CNC machines are controlled with G-code instructions – similar to 3D-printers. An example of such an instruction is: “move to x 500 y 700, and drill a hole of 5 millimeters deep”.

We used RhinoCAM to create G-code. It takes a bit of trial and error to get things right, so you’ll need to go back and forward between the settings and the simulation. This honestly felt a little like a black art to me, something you can only learn by doing it many times.

Generally you’ll want two different stages:

• roughing: first take away large portions of material quickly with a large drill
• finishing: then do the finer work with a smaller drill

This is the roughing stage:

This process took about half an hour in my case. This second stage, the “parallel finishing” took a few hours:

You can clearly see the difference between the left and right side. This is how both sides look before cleaning:

5. Preparing for casting

After some initial tests, it was clear that I would need a huge amount of resin to cover the volume of the sphere. My first solution was to lasercut a box from plexiglass. I used BoxMaker, a little webapp that makes it easy to create a PDF with the necessary shapes for a box. The is how the box looks after glueing:

My plan was to hang it in the center and glue the LED’s on it:

And then I added ping pong balls to fill the rest of the volume:

Then it was time to prepare the mold for the resin. First, the foam mold needs to be covered with a product to seal all holes. After a 2 or 3 layers of this, another product needs to be applied that should make it easier to get the shape out of the mold.

I used a transparent resin. These products are quite expensive. I used one box, which is around €30 – €60. This is also pretty nasty toxic stuff, so wearing gloves and a mask is required. This is how it works: the products comes in separate 2 liquids, which need to be mixed in the correct proportions:

The two halves of the mold should be tightened together.

You’ll need three holes: one to pour in the liquid, another one for air, and, if you’re making a lamp: a hole for the wires.

The resin needs time to harden, I my case 24 hours. My mold was not 100% tightened, which made it very hard to open the mold without destroying it:

After some effort I got it out of the mold:

¡Hola – This is our second fabrication assignment which is about creating a mold  for an objects that glows. My first round of the experiment wasn’t very successful, as the only thing that ended up glowing properly was probably me!  However, let me give you brief hints on how to avoid what went wrong, and what I would like to do for take 2.

I made a very simple object that has a lens shape and a magnifier effect on it, so it literally, it is a “lens within a lens”. . You can easily find the lens effect on Mathematica and then you have multiple ways to do it, using a python script, grasshopper, or simple extrusion surface commands . After creating the object, step 1: is to work on the mold, which is basically a negative of the object volume, split into two halves (make sure you have a hole that reaches all the way to your void).

After the mold, step 2 is: you should prepare your object for machine milling, which starts by checking materials you will engrave, and exact measurements for tools. Communication to CNCs happens via G-codes, which could be generated using multiple tools. In our case we used RhinoCAM _which I am not interested in promoting how to use it_ the point is, you should be able to simulate the exact milling motion before you start milling.
Tip: It might help to run small test on the material before you actually start milling.
In my case, we used two leads a 12mm and a 3mm and it took nearly 20 hours. Tip: It helps to calculate the time required for milling before you start.
After milling, step 3 is to clean your object and work on the lights. I used simple LEDs connected in parallel and inserted then where the magnifier effect is. Tip: Test all your LEDs before using them, and keep testing after every step you finish. Just keep a battery in hand for quick testing. Now, step 4 is to get messy and work on the resin, in this case we used SmoothCast 327 which is supposed to dry in 2-4 hours. Before mixing, step 5 is to get your mold coated with anti adhesives, so that you can get your body out.

We used several seals in different layers , however the absolute superstar of the process was, liquid vasilin (thanks to Natasha!)

Follow the instructions on the package and start mixing. Tip: It helps to actually calculate how much you need before your start, and also to test a small sample. For allergic people like myself, make sure you put your gloves and masks (and glasses if needed on), otherwise the best case is that you will end up with headaches and rash!

After you pour the resin,  step 6 is to tight your formwork with clamps and wait for the right time to open it (4 hours in my case). Now take a deep breath in, and open your box... I had a bad surprise waiting for me: Apparently, the resin didn’t reach all the holes (because I stopped shaking the formwork once the resign started to flow outside it). Which ended up in the result you see. Now the final product looks more like a demonstration of a skin disease rather than a lens effect, but well, at least the lights still work .

Take 2: I just found an opensource Gcode generator that runs on blender and has a simulator for milling. So, lets make a simple object and test it to see if this stuff actually works. It will be better to have a detailed Linux based tutorial, and maybe test different materials _more ecological_ for resins.

Hasta Luego!