At the early hour of 9:30AM, I was awoken by a call from from my friend at NASA. Apparently, in a nondescript patch of what was once thought to be emptiness, new features of the Thingiverse have been discovered! New information is still pouring in about the exact nature of the discovery, but apparently it has to deal with the building blocks of Things themselves. They have discovered a completely new Parts nebula that is literally swarming with parts and suppliers.

You see, the Things we deal with are typically made up of many individual Parts. For example, even a simple hairpin needs 3 parts: 2 printed ones, and a spring. As you create more and more complicated Things, the number of parts goes up dramatically. Something relatively simple like a PCB holder vise has numerous parts that must be printed or purchased in order to build it. On the extreme end of things, a complicated machine like the CupCake CNC has hundreds of parts which are all critical to its operation. The issue of how to properly catalog and specify these parts has caused engineers and hobbyists alike much frustration.

Now, with the discovery of the Parts Nebula, those days may soon be behind us. With this new data, Thingiverse citizens may now create structured part lists that can be shared and even embedded in their own websites. These part lists are designed to be as helpful as possible. They print out very easily for a trip to the hardware store. For those who prefer to shop online, suppliers can be added to parts to streamline the online part hunt. Parts themselves can be reused between Things, which saves time and effort. Last, but not least, there is an inventory system which allows you to keep track of what parts you have.

So, lets explore the new findings a bit deeper. Luckily the new ’screenshot’ system that was installed in the Hubble has resulted in wonderfully crisp images of the new features.

Here we see a completed part list on an Opto Endstop, an electronic component used in MakerBots and RepRap machines:

Here, we see the exact same part list, but embedded in the MakerBot wiki:

The embed is a very useful thing. It contains Part IDs, names, and quantities, and many useful links. We’ve embedded it into this blog post for you to play with:

Let’s take some time to explore a few of those links. Each part name links back to its own individual page where you can find information on the part such as your inventory, suppliers, photos, and even other things that use that part:

The embed itself contains the code needed to embed it on a different site, so maybe the partlist you design will become viral and spread its wings across the net.

The nice thing about the embed being an iframe, is that only the iframe will be printed when you click the print button. Put the part list in your pocket and head to your hardware store / hackermart and pick up those last few parts for your Robotron.

Last, but not least there is the shopping cart feature. This is a nifty little bit of software we’ve been that allows you to locate suppliers where you can purchase the parts you need. Notice in the screenshot that it integrates with the inventory system:

Oh, did I mention the inventory system? Yeah… you can add any of the parts on Thingiverse to your own personal inventory system. Complete with inventory export, logging of inventory transactions and barcode scanning support. We built it because we needed it, and we’re sharing it because we love you.

Of course, you’ll actually have to use this system at some point in time, so here’s a look at the interface for adding parts to your thing:

Okay, this is pretty spiffy.  The glow from this box comes from an LED that’s part of a beam-break sensor.  Little mechanical innovations like this really excite me.  Add this to the growing list of things like the electromagnet demispool added this week, which represent a pile of parts Thingiverse users will have in their toolkits when it comes time to make more complex projects.  Neat!

I saw this on Make and thought “Now someone on Thingiverse could bodge up a part like that pretty quickly!”

So I’m testing a new segment: the Remake Challenge.  I’ll look at something cool out there in the maker community and do a post challenging the Thingiverse community to make it into a sharable, personal fab-able object.  If this generates lots of interest or responses, I’ll make it a regular feature.

So for our first Remake Challenge we have an iPhone tripod mount, which looks to me like something the Thingiverse community could do pretty easily and possibly even throw in some design flair.  For the first challenge, I think I’ll be pretty happy if I see even one of these, but later on, with a bigger community, I can imagine design challenges resulting in whole baskets of alternative designs with their own benefits and drawbacks, which needless to say would be really awesome.

In the previous GCode tutorial, we covered the creation of GCodes using Python, and introduced the basic structure of a script that uses GCode objects as a tool for creating GCode files.  In this tutorial, we’ll move from Para01.py to Para02.py in the first GCode Script Pack. In this file, we’ll start using the math library to create circles from straight GCodes.

First, a bit of bookkeeping.  Using trigonometric functions means getting back floating-point values with lots of decimal places of precision, but in a GCode file it’s usually a bad idea to have more than a few decimal places of precision, since it bloats serial operations and finer than 10um precision isn’t attainable on most current hardware anyway.  So we need a rounding function to truncate these floating-point numbers. My friend Ryan Vilbrandt was kind enough to lend me his:

This is called from the GCode string output function later to make sure that the GCodes sent to the file are tidy.

In the next step, we’ll use the parametric formula of a circle:
X = cos (T)
Y = sin (T)

Inside the Zsteps loop from the previous example, we put a loop for Tsteps equal to two pi radians (360 degrees) minus a little bit.  Here we do 62 steps of 0.1 radian each:

Smaller steps will make for shorter GCodes and a more perfectly circular curve, and larger ones will even produce visibly flat sides to the cylinder.  This script can be used to make shapes like octagons and pentagons by reducing the number of steps to the number of desired sides.  Additionally, by entering an integer multiplier into one or both of the trigonometric function arguments, this script can generate lisajous patterns.

There are a lot of shapes that can be build based off even this simple example– scripting GCodes directly isn’t going to work for every application, but it’s a great way to build certain classes of objects, and doesn’t require learning how to use a 3D modeling tool.

There’s a really great article in this month’s Wired on the “Lo-fi revolution” sweeping the tech world one industry at a time lately, and my thoughts immediately turned to the MakerBot and the RepRap, which deliver a lower resolution than commercial 3D printers, but at such a tiny fraction of the cost that they utterly change the game.

This is, according to the Wired article, just what the mp3, Hulu, and the Flip video recorder have done: provide a known benefit at a lower resolution or fidelity or precision, but using the other side of that trade-off to arrive at something unprescedented: in the case of the MakerBot and Flip video recorder, it’s a price so low the market potential hadn’t even been considered previously.  In the case of mp3, it’s a file size so much lower than uncompressed audio that amounts of music can be stored that’d be unheard of without compression.

In the above photo, there’s an example of this: parts for 3D printers, whether for replacement, upgrade, or decoration (what is referred to in more colloquial circles as “bling”) can be printed ON a low-cost, low-fidelity 3D printer at a cost which is transformitively low.  The lower fidelity of thermoplastic extrusion on 500um print heads with no support material or build chamber temperature control compared with the big dogs is exchanged for a super-low cost and an open-source architecture which makes repairs cheap.  The result has, so far, been a newborn but rapidly-growing Cheap 3D Print sector, as well as a whole lot of traffic and design passing through Thingiverse.

I think the next big thing to happen in the personal automated fabrication market could learn something from this: the secret to success might be in finding a tradeoff that can be exploited rather than in better precision or higher detail or a merely larger build area.  Perhaps a powder-based system could sacrifice the durability of thermoplastic parts for the high resolution offered by using pre-existing ink cartridges to bind a cheap powder substrate.  Maybe this MakerBot as Case Mod project will turn into a computer that also prints 3D parts, transformative because if you think of the MakerBot as a PC case, the printer itself doesn’t have much of a footprint at all.

The enabling aspect of technology is a force to be reconed with, and it often trumps traditional values like precision and feature richness, especially when a new approach to a problem like fabrication earns as much for a tradeoff as the low-cost 3D printing sector has.

I think the user-innovations on 3D printing are doing pretty well, yeah.

Once again, an amazing week on Thingiverse!  There’s a pen holder and a vase, the desk clamp parented a superb PCB clamp, the experimental front saw work on an electromagnet project, and the printable compass marks yet another everyday tool that can be printed.  There was also a healthy pile of objects copied from reality!  Go 3D archives!

But for sheer photogenic cool factor, it’s hard to go wrong with an accessory that turns a tube of glowrods from a bundle of  bracelets  into an arc-bent polyhedron factory!  This is a great example of 3D printing working in harmony with commodified infrastructure to produce things neither would likely do alone.  Adding to the cool factor is that the photo of this design actually working doesn’t come from the designer, but from another maker on Thingiverse.  Increasingly, fabricators and designers are using Thingiverse to collaborate across any distance at all to reshape reality!

Blender seems to add a lot of vertices whenever you import an STL file.

This doesn’t happen on export, or if it does it hasn’t bothered Skeinforge, but I’ve had meshes fail to slice in Skeinforge because of the vertices that got added when I imported to Blender, resized, and then exported without removing them.  The first thing you should do after importing an STL in Blender is to go to edit mode, select all, then select “remove doubles” from the vertices submenu.

This tutorial series will show off ways of making your own GCode files directly with python scripting.  In a lot of applications, it can be more efficient to work directly on GCode than to build a 3D model.  Further, directly modeling a shape can be less fiddly than skeinforge, particularly ones with single walls.

This tutorial will explain the file para_01.py found in the GCode Starter Kit. If you’ve never programmed before, you might want to study a few tutorials on the Python language, but this program is simple enough that if you’ve got the basics down, it shouldn’t be too hard to deal with this one.

The first few lines in this file are a “class definition” for an object called G1Code.  In the case of this file, this is just a handy way of storing the variables X, Y, Z, and F (F is feedrate) and a good place to put the function that makes a text GCode out of those variables:


#G1 Code Object
class G1Code:
def __init__(self, X=0, Y=0, Z=0, F=0):
self.X =X
self.Y =Y
self.Z = Z
self.F = F


def __str__(self):
string = "G1 X" + str(self.X) + " Y" + str(self.Y) + " Z" + str(self.Z) + " F" + str(self.F)
return string

With the above definitions in place, we can now access the coordinates in an object of type G1Code by adding a .X, .Y, .Z, or .F to the end of its name. We can also print a gcode just by calling str(G1Code). Next we’ve got some variable declarations:


filename = "test.gcode"
Zsteps = 0
ThisGCode = G1Code(X=0, Y=0, Z=0, F=1000)


This program only has one G1Code object– we just change its value repeatedly and write it out to the file after each change. Next, we’ll take that file name, open a text file, and write out headers. Thes GCode and MCode references explain how these settings tell the printer to operate in absolute coordinates, milimeters, and set up the extruder.


FILE = open(filename,"w")
FILE.writelines("G21\n")
FILE.writelines("G90\n")
FILE.writelines("M103\n")
FILE.writelines("M105\n")
FILE.writelines("M104 S220.0\n")
FILE.writelines("M101\n")


Now that we’ve got a header, it’s just a matter of using a loop in the program to lay down each layer of the shape. In the case of this program each layer is the simplest shape possible: a triangle.


for Zsteps in range(30):
#Hop up to the next level, staying put
ThisGCode.Z = 0.4 * Zsteps
FILE.writelines(str(ThisGCode)+ "\n")

#Trace out the prism
ThisGCode.X = 0
ThisGCode.Y = 0
FILE.writelines(str(ThisGCode)+ "\n")
ThisGCode.X = 0
ThisGCode.Y = -10
FILE.writelines(str(ThisGCode)+ "\n")
ThisGCode.X = -10
ThisGCode.Y = 0
FILE.writelines(str(ThisGCode)+ "\n")

(Wordpress isn’t being friendly to my tabs, but they’re in the original file, and you do need them, because Python uses tabs instead of brackets to indicate loops and subroutines.)

Note that inside the loop there are four print commands.  The first one contains the value of the last GCode on the previous layer (or just zero if there is no previous layer) plus a slight vertical shift.  The other three move the print head first to the origin, then back ten milimeters, then diagonally down to a position ten milimeters left of the origin.  From that position, the next pass of the loop will move the print head up again, then around the triangle.

The print generated by this code isn’t very tall, or very large, or very tall, so you won’t waste a lot of plastic on messing around with the settings and trying new things.  Leave any questions in comments, and I’ll use that to gague whether the next one of these needs more or less of anything.

The Utah Teapot is one of the iconic shapes of 3D, as I said before when this puppy showed up on Thingiverse.  And while any CS geek I show this to goes into proxysms of glee, I was surprised at how positive a reaction I got at my Saturday morning coffee clatch, which consists mostly of retirees.

Although most of these people aren’t technologists, they do like a good gadget now and then, and my parametric prints were well received as “neat”.  However, the teapot really got me some unexpected enthusiasm.  The Utah Teapot is an icon of 3D for a reason: it’s instantly, unmistakably recognisable as a teapot.

To this group, making things like gears and hex grids and suzanne the blender monkey might be interesting, but something that is instantly recognisable as a plastic teapot, that’s cool.  I’ve given away four of them now, and I plan to bring a few more in next week as well.

The hardest part about being involved in experimental technology is often dealing with how unimpressive it can look to outsiders.  One of my favorite quotes from the excellent Replicator blog is this one about Spore’s figure print service:

I brought it into my office and all the engineers said “whoah, cool!” and everyone else said “why is it so dusty?”.

Having non-engineers ask me if they can have one of my prints, in a known melieu like this one, that’s, well, cool.