Enter the support peg.

The idea is to basically extend a vertical support peg through your model, allowing the fairly common practice of bending or breaking the “45 degree rule” to stretch a little farther than it usually does.  For my example I’m going to use this adorable but tough-to-print stegosaurus model:

The body could use a little support, but the big trouble will be the head and tail, which on a 3D printer without support material will have undersides coated with strands, and may cause some “pull-up hazard”, meaning that the strands might get caught on the print head and yank the model off the build area.  So let’s get this file into OpenSCAD, which I’ve found is a great tool for putting posts into models because of its solid geometry tools.

I recommend you put the file in your OpenSCAD installation directory for now, although some people like to have a separate directory for the files.  Either way, make sure you have the whole path to the file for the next step, starting your OpenSCAD file.  (If you’re still new to OpenSCAD you might want to check out my getting started tutorial or even try the big list of them.)

import_stl("/home/allan/Downloads/dinosaur.STL");

(I found that for some reason I had to open this file in Blender and re-save the STL to get OpenSCAD to like it.  This might be due to some non-uniformity with how STL is implemented and is an example of why it’s good to know at least the basics of a few tools. I also rotated and translated it so it was sitting upright on the origin.)

Now you’ve got it in OpenSCAD you should get a picture like this:

With that done I started in with the pegs.  Each peg is a “cube” object stretched into a thin post and unioned onto the dinosaur:

union()
{
import_stl("/home/allan/Downloads/dinosaur.STL");
translate([-45,0,-37])cube([3,3,100],center=true);
translate([-35,0,-35])cube([3,3,100],center=true);
translate([-55,0,-35])cube([3,3,100],center=true);
translate([-25,0,-35])cube([3,3,100],center=true);
}

Now the dinosaur has long posts coming down out of its neck.  At 3x3mm, they should snap off fairly easily, but they extend a long way down past the feet.  This is intentional, because I’d rather use my next trick to get them exactly the same height as the feet, and simultaneously make the feet a little flatter.  Intersection!

The bit of code I’m adding uses the intersection operator to cut off the bottoms of all the pegs– and just a little bit off the dinosaur’s feet!  I basically did this by typing in numbers, hitting F5, and then doing it again until I had the height *just right*:


intersection(){
union(){
import_stl("/home/allan/Downloads/dinosaur.STL");
translate([-45,0,-37])cube([3,3,100],center=true);
translate([-35,0,-35])cube([3,3,100],center=true);
translate([-55,0,-35])cube([3,3,100],center=true); translate([-25,0,-35])cube([3,3,100],center=true);
}
translate([0,0,23])cube([290,60,60],center=true);
}
The new version of the STL should print much more smoothly!

In the tutorials so far, we’ve got some basic CSG working, it’s time to start using the more powerful tools that combine the CSG toolset with a programming toolset. First, constants. Constants are defined in the same way as variables in C or Java, although they don’t have types since they’re all floating-point numbers:


x=20;
sphere(x);
translate([0,0,-x*1.7])sphere(2*x);


A word of warning though, these aren’t variables in the classical sense. If you want to change them halfway through a file, you’re out of luck. A second declaration will overwrite instances of that variable, including those earlier in the file. The following code:


x=20;
sphere(x);
x=10;
translate([20,0,0])sphere(x);


Will actually produce two spheres of the SAME size, 10. (This doesn’t apply to the arguments of modules, however, so if you need to reproduce the same object with different parameters in the same file, you can use those.)

Another great tool is the for loop. For loops are another staple of the programming world, and in their simplest form you can use them to drop down the same shape repeatedly with some (or many) parameters changed as a function of the “iteration variable”, in the case below, i:


union(){
for (i = [0:19]){
rotate([0,0,i*360/20])translate([-50,0,0])sphere(10);
}
}


The above loop sweeps the sphere around in a circle to create a ring of spheres. For each value of i from 0 to 19, a new sphere is placed with a different rotation. (The translate step moves the sphere so that the rotate step is rotating it around a point 50 units off center.) Neat, huh? This is a great tool for adding details like ridges, or for creating mathematically defined shapes.

With different notation, the for loop can also be given a sequence of discrete values:


for (i = [3, 5, 7, 11]){
rotate([i*10,0,0])scale([1,1,i])cube(10);
}


Here, we rotate and scale a cube by a set of primes.

The for loop works in OpenSCAD with the CSG toolset, so you can union or difference objects generated by for loops to create complex structures. (You can use intersections as well, but you’ll have to use the workaround described in the documentation.)

In the previous OpenSCAD tutorial, we built some basic shapes using the boolean operations and translations. With these, you could readily copy and paste a section to produce multiple copies of it, but this would get long in a hurry.

However, like any good programming language, OpenSCAD comes with support for modules and loops.

In the case of modules, OpenSCAD allows you to define a recurring pattern, with arguments. For example, the last example from the previous tutorial can be expressed as a module with a position:

module Pawn(xpos, ypos, zpos){
translate([xpos,ypos,zpos]){
union(){
cube([40,40,4],true);
cylinder(40,15,5);
translate([0,0,40])sphere(10);
}
}
}

With this at the top of an OpenSCAD file, we can now instantiate one of these anywhere, union groups of them together and so on:


union(){
Pawn(0,0,0);
Pawn(15,0,0);
}


With modules, complex objects can be readily assembled from variations on a shape.

It’s also possible to use loops to draw multiple copies of the same shape with some variation such as position, and they can be put inside boolean operations:


union(){
for(i=[0:3]){
Pawn(0,0,0);
Pawn(15*i,0,0);
}
}


Combining modules and loops, models can be made parametric, so that with some clever code you can have a user enter in a few numbers and get a part that fits a job exactly.

It’s pretty much a blank page.  However, modern versions of OpenSCAD, like Processing and the Arduino environment, come with examples, pre-linked in the file menu.  However, if you’re a 3D newbie or just haven’t done much with solid geometry, even the first example file is maybe a little daunting at almost half a page, with rotations and intersections and stuff.  We’ll start with the simplest file that will render, export, and print.  Ready?

cube(40);

Riveting, right?  That’s a 40mm cube sitting with one corner on the origin.  (You can go to the View menu to show the origin, which can be really helpful.)  If you hit F5, OpenSCAD will display this cube in the window on the right, and you can drag in that window to rotate the view around, and roll your scroll wheel to zoom.  Pretty easy, and fairly boring.  Let’s make this one step more complicated to get a compound shape:

union(){
cube(40);
translate([10, 10, 30]){cube(20);}
}

This file has two new operations: translate and union.  Once you’ve typed or copy-pasted this into your window, hitting F5 will give you a cube with a bump on the top.  This is done with two new operations, so let’s tackle them one at a time.  First, the translate operator.  The translate operator takes a triplet of numbers (also known as a 3D vector) which moves the contents of the brackets after it in three dimensions by the three numbers stated.  Inside the brackets, we’ve put a cube of size 20, which starts like the first one with its corner at the origin, but is then moved by the translate operator ten units right, ten units forward, and thirty units up.

Surrounding both cubes in the descriptive language here is the union operator, which binds these two cubes together as one object so that when the file is rendered to an STL file, it will seamlessly combine these two cubes into one object.  (This isn’t a hard object to model in Blender, but when you’re unioning a lot of objects Blender will kick up its legs and die where OpenSCAD will keep chugging merrily along.)

If you replace the word union with the word difference here, you’ll get the difference operator, which cuts the second cube out of the first.  Union and difference operators are basically the core of how this geometry tool works, and you can get a lot done with just those and the cube, sphere and cylinder primitives.  Here’s a simple file that makes use of all three primitives to get you started with them:

union(){
cube([40,40,4],true);
cylinder(40,15,5);
translate([0,0,40])sphere(10);
}

The cube primitive here has been given a vector instead of a single number, which allows you to make it any rectangular solid rather than a simple cube.  The “true” keyword at the end of either a cube or a cylinder statement sets the primitive to start centered on the origin.  (This is all the free translation you get though, after that you must use the translate command.)

So hopefully this was simple enough for those new to 3D and CSG but had enough content to get you properly started– the surveys so far seem to indicate there’s a lot of desire for extremely simple examples so hopefully this fits the bill.

So then, here’s Blender’s new interface as of the 2.5 recode:

The middle panel is your 3D view, and it’s most of what matters here. Here are the basic navigation controls for simply looking at what is in the 3D view. (We’ll get to actually making things in a second.)

On your number pad:
7, 1, and 3 are top, left and front views, respectively.
5 toggles perspective in the view.  (Things further away will look smaller in perspective mode, not always what you want for mechanical design.)

A mouse with a scroll wheel is highly recommended for Blender, as it gives you the following features:  Middle-click and drag to rotate the view.  There’s an invisible point in the center of the screen around which your view of the scene rotates. This point is not marked by anything (That little red-and-white ring is actually the 3D Cursor, about which we’ll learn more later), so it’s a good idea to occasionally twist the view a bit with middle-drag, which you’ll usually do a fair bit when modeling.  You can also use the scroll wheel to zoom the view, so if you roll the wheel back, you’ll zoom out, rolling forward, in.

One odd property of Blender: right click to select.  This is a bit odd, and you can change it, but it’ll make other tutorials wrong so I tend to recommend getting used to it.  Highlighting defaults to an orange outline, so it should be obvious when you select anything in the scene.  Another tremendously useful feature is the period key on your number pad to center the view.  When you are rotating the view with middle-drag, you will rotate around the last place you selected with the period key.

The 3D view has six modes. If you click on the mode icon on the lower left of the view, you’ll see this list:

However, if you’re only going to be doing design for 3D printing, you won’t need all of them, and at first you’ll only need the Object Mode and Edit Mode, and the Blender developers have made the tab key the shortcut for jumping between them.

Once in Edit Mode, you’ll have the ability to select the individual vertices of the mesh.  All the above tips still work, which is why the six modes above are all part of the same 3D View framework: this way, your basic navigation tools will always be the same.  (This is a recurring theme in Blender: if something works as a way to do something somewhere, chances are good that it will do the same thing or something similar in other views.)

You can now select and shift-select to select multiple vertices.  There are shortcuts for moving, scaling, and rotating vertices or groups of vertices:

g key to “grab” or drag vertices
s key to scale vertices
r key to rotate

While you are doing any of the above, you can either left click to accept or hit the escape key to abort your changes.  You also may hit additional keys to refine these motions: x, y, and z to restrict to an axis, or hold ctrl to move in discrete steps.

Blender is a complex tool to do a complex job, and the subset of Blender associated with solid modeling is still pretty large.  Hopefully though, this guide of the 3D view is enough to get a sense of the key weirdnesses to Blender’s interface design so that you can get on with modeling.

Other Blender guides:
BlenderCookie Getting Started Guides
Blender: Noob to Pro Wikibook

Okay so you’ve got Blender and you’re trying to model something with lots of drill holes and Blender’s solid boolean operations are driving you up the wall.  Meshes hash into mounds of needle-like triangles quickly, and needle-like triangles break the boolean engine.  Nature of the beast, I’m afraid, Blender is a mesher.  And meshers aren’t anything like SolidWorks or OpenSCAD, which can handle hundreds of boolean operations without batting an eyelash.

But let’s say you’re not in love with coding object positions by hand and SolidWorks isn’t in the budget.  Now what?

Subsurface Modifier to the rescue.

Now even a judicious use of the Subsurface Modifier isn’t going to make everything easy, but it can get a lot of your print jobs way closer to that SolidWorks beveled look, let you punch holes in your meshes with relative ease, and dramatically reduce the number of vertices you have to fiddle with.

For this you’ll need a few tricks, so to make them easier to “get” we’ll start in 2D topology, with a flat plane:

This plane’s simplest description is four points.  Makes sense.  Now, let’s switch on the subsurf modifier:

Okay, weird, right?  Our plane is now an octagon.  Blender has subdivided the plane into four quadrilateral faces (or Quads as you’ll hear the meshers say) and rounded them off.  If you turn up the number of subdivisions in the subsurf panel, you’ll see that this octagon is really approximating a circle:

Now if you’re trying to do something mechanical you’re thinking, well that’s kind of useless unless I want to do talking animals or trees or possibly certain very abstract shapes, how am I supposed to do anything with sharp edges?  Answer, by telling the subdivider to make the edge sharper, which is easier than it sounds.  Hit ctrl-r for the ring-cut function, and when the mouse pointer is near an edge, it’ll draw a line showing where it’ll cut.  Click once, and you are now sliding that edge back and forth.  Slide it up close to one side like this:

Which you can quickly extend to getting a square back:

Which great, you’re thinking, we just did with nine quads what we could have done with one.  But now we get to the useful bit– punching a square out of this mesh creates a circular hole.  Any time you are working with a mesh defined like this one, circular holes require almost no vertices to get satisfactorally round results.

With ctrl-r and the subsurf modifier, you can get away with designing your entire project as though it had no soft edges and all circles were squares, then adding the subsurf at the end and “sharpening up” the corners you want sharp.

For example, here’s a sort of cylindrical goblet with a square hole punched through the side:

(I removed two faces, extruded once to get some surface area back and then stitched the two holes together with the f-key command.)

With the subsurface modifier, it gets smoothed off into this:

Which is pretty cool, but it’s missing some sharp edges that I wanted.  The ring-cut tool lets me sharpen up a lot of edges, like the ones highlighted:

With some fiddling, I was even able to square up the hole on the side.  Important benefit here: if you have two parts which need to fit together, sharpening up their edges where the original meshes touch will move vertices towards the places they need to be for a mate.  I’ve used this at my job to press-fit parts together, and it works!

A lot of entries to Thingiverse are missing things like descriptions, working previews, or separated STL files.  This is more of a checklist than a tutorial, but it seems a fitting topic for the last day of printability week.

First, the model files themselves.  Make sure you have done your manifold checks, check your scaling, and make sure you have your STLs arranged appropriately in their files.  If they are meant to be printed in a specific orientation, make sure they have that orientation.  If your model contains a really large number of STLs, consider including a zip file for ease of downloading.

Second, make sure you get a title and basic description in there.  The tab for adding titles and descriptions is over on the left after you upload, don’t forget to visit there before hitting that publish button!  And while you’re there, don’t forget the Licensing dropdown!  For those of you who are new users, Thingiverse doesn’t default to an open-source license, so make sure you make a choice that you’re comfortable with.

Third, go through the tagging fields and click some.  It’s unlikely anyone will complain if you don’t, but doing so will make your model easier to find when someone’s looking for it later!

Finally, if you’ve got extras, add them!  If you have sketches from early in the design process, or documentation for use, or the original files for your modeler of choice, these all add to the treasure trove of stuff available on Thingiverse, and make it a more inspiring place to be!

There are a LOT of 3D packages people are using to create models for Thingiverse.  From the ultra-professional (and ultra-expensive) CSG package SolidWorks to free, lightweight modelers like AOI, the diversity is huge.  And it all funnels into one format in the end: STL.  Without an STL, a lot of printer operators will dismiss an object without so much as a glance at the format it’s in, because hey, if you haven’t exported to the standard format, what else might you be forgetting?

Fortunately, many of the tools have STL as an export option, so it’s mostly more of a checklist thing than a real technical challenge.  Also, Blender can export to STL, and import from a really crazy number of formats.  Also, if you remember having a horrible time getting Sketchup files to STL, you should check out the latest version, as it’s much easier now: the most recent free Sketchup version exports to .dae, which Blender supports!

(Note Blender’s fairly massive list of supported files, although so far only in 2.49)

Tomorrow, we’ll take a quick overview of the total checklist when uploading to Thingiverse for maximum printability!

Now of course, I rattle off the following without hesitation:

3D Printing with extruded thermoplastic is not like printing with an inkjet.  It’s more like using a pen plotter.  When the printer is running, a thin noodle of plastic is being squeezed into place along a set path.  So rather than “voxels” what you really have is a minimum layer and line thickness.  And that line can be placed to a precision much higher than the thickness of the line, so what you can and can’t do is kind of a weird question.

Another question I get is, “how long does it take to cool?” and again, the answer isn’t as easy as the question makes it sound.  In this case, the answer is that the bottom is cool long before the model is done usually, and when the print finishes the top is still a bit molten.  Both of these little stories are key to understanding how your model looks to an experienced printer operator.

Minimum wall thickness is a specification you’ll read about in a lot of the 3D printer ads.  Models with very thin protrusions can be really difficult for a 3D printer to create, and those protrusions will be more susceptible to all manner of glitches and hiccups.  Take this rose I designed for example:

The petals are tall, thin structures near the minimum wall thickness.  This is problematic for several reasons, but let’s look at wall thickness.  As the print head draws the outer perimeter of each petal, it’s laying down very little plastic, which won’t have long to cool before the print head moves on.  As a result, any problems with the print head lifting plastic as it moves from place to place will be magnified.  This rose doesn’t break the 45-degree rule, and it’s manifold, but it’s going to be one tough print to get right.  Keep in mind that small details near the wall thickness limit will make your model harder to print properly, even if it’s still technically possible.

Another problem with this model (I had a real field day pointing out the flaws in my design once the first 3rd party print of this showed up) has to do with the many tall petals.  Each petal is going to be molten on the top as it prints.  When considering how easy something is going to be to print, imagine your model partly build and all the plastic near the top is gooey and soft, and a hard, hot nozzle is swooping around scant microns above.  If you winced doing that for the rose model, you’re thinking about it right.  As the nozzle jumps from petal to petal, it’ll be liable to pull up plastic or bend the petals and mangle this delicate flower.

There are Skeinforge settings to fix things like this.  (In particular, COOL, and Oozebane.)  I’m very sure that there is a way to get a halfway decent rose out of a MakerBot.  But with those thin protrusions it isn’t an easy print, and it’s also a good illustration of some things to think about if you’re trying to make a model that is not only printable, but easy to print well.