Full confession: when you look up “3D Printer Newbie” in the OED, you’ll see a picture of me.  I am early on this particular learning curve but as enamored of it as most people who start down this path. This of course means I must somehow connect it to my primary area of interest, Salesforce. That is what I’m going to talk about today.

This post has six parts. 3D Printer Fundamentals, Introducing OctoPrint, The Salesforce Side of the House, Code Review, Practical Applications and Things That Went Wrong Along the Way.  But let’s start with a demo!

(Yes, that bonus soundtrack you hear in the far background is in fact my child.)

3D Printer Fundamentals

My work here was done with a couple of PrintrBot Simple Metal printers I picked up online. They’re not the most advanced printer on the market — if anything, they’re a minimalist interpretation of the form — but they are pretty sweet and at $599 the price is certainly right.

3D printers are what’s referred to as “additive manufacturing.”  This means they start with nothing and add something to create their output. Most 3D printers on the market extrude thin layers of plastic over and over again, and these devices share a few common attributes.  First, since they work in three dimensions, they must be able to move a printhead in three dimensions.  I’ve labeled these as the X, Y and Z axises above so you can see which parts of the PrintrBot move. Second, they have a micro-controller that moves the printhead and regulates temperature and a bed that holds the results.  Finally, they all have a feed that moves plastic filament into a hot end where it melts and is extruded on to the bed.  For filament, I used 1.75mm wide PLA (plant based and compostable).  Layers are about 0.3mm thick, and come out of a 0.4mm hot end nozzle at 190° C.

Controlling a 3D printer is a cooperative effort between the onboard micro-controller and host software. The host software feeds printing instructions to the micro-controller which in turn provides operating details back to the host software.  The most important of these operating details is the temperature of the hot-end.  Probably the most common host software you will hear about is Repetier, and it’s definitely a great way to go. However, it’s not the only way to go and I ended up using another one for this project, which I’ll get to in a second.

Now, this is most of the picture, but you still need to tell the host software what you want to print. A 3D print generally starts off as a 3D design in some kind of CAD program.  There are a bunch of these you can choose from.  SketchUp is popular and free for non-commercial use, TinkerCAD is an online web-app that does it, and there are a bunch of others.  Once you have a 3D design, you need to convert it to something your 3D printer can understand.  Slic3r is the tool of choice for that. It converts 3D designs into a “gcode” file that contains actual instructions your printer can use.  If you want to use someone else’s design to start, checkout the good people at Thingiverse.  They have a lot of designs you can download and use for free.

Introducing OctoPrint

Probably the best part of my job is poking my head into a new-to-me corner of the technology world and discovering an unexpected gem. OctoPrint is that gem. OctoPrint is 3D printer host software delivered as a web-app. It’s open source, written in Python, optionally runs on a Raspberry Pi and the devel branch has a pretty sweet API.

If you’ve read any of my earlier posts about controlling quadcopters, Philips Hues or DIY wireless sensor networks, you probably know what happens next.

If you guessed:

You are correct.  The basic setup is pretty simple.  I install the OctoPrint friendly Rasbian distro OctoPi (yes, it’s as easy as they make it look — completely awesome, too) on a Raspberry Pi I have sitting around.  I then added Node JS to it and created some familiar looking JS to talk to Salesforce via the Streaming API. OctoPrint talks to the PrintrBot Simple by way of a USB cable, so nothing special there. Also, in case you’re curious, I opted to have a single Pi control a single PrintrBot, so the setup in the video requires two units.

(Incidentally, I wanted to mix this architecture up this time, but was stymied.  See “Things That Went Wrong Along the Way” below for details on that.)

The Salesforce Side of the House

Let’s start with the data model.  It’s pretty easy, but a little different than the ones I’ve used before.

Historically, I’ve used a single message object.  The OctoPrint API is pretty rich, though, and has a variety of requirements (some commands are GETS and others are POSTS with bodies requiring a JSON object, for example), so I added an additional object to store API Command Templates.  The UI simply lists the available commands, and then creates a printer message based on the template.

I really like this approach because it let’s me add new API commands as data, not metadata, so it’s super easy to add functionality and update the system as OctoPrint changes without having to deploy code.  (I can’t remember who, but I think I’m stealing this idea from someone.  Sam maybe?  I hate it when I can’t remember, so ping me if it’s you.)

Notice I don’t have a Printer object here. I do have one in the code, but it only holds names. It should be a relationship on the Printer Message object, but I didn’t get around to it.

The rest of the app is plain old Visualforce and Apex.  I’m not using any of the modern JS frameworks (Angular JS, etc), and I haven’t gone out of my way to optimize queries etc.  As you can see in the YouTube above, it performs pretty well.  The longest delay is doing the asynchronous round trip all the way back from the PrintrBot.

(Full confession: Christophe talked me into adding a little padding around the page so the Bootstrap based CSS didn’t extend completely end to end.  He was right.)

Code Review

As I said, the code on the Salesforce side of the house is pretty basic.  You can see it on the Github repo and yes there’s a link to an unmanaged package there too.  Literally all I’m doing is inserting an object based on a template contained in another object. The code that’s doing the interface is pretty similar the the quadcopter code, but it has a couple of twists.  The full gist is here.

In the likely event you don’t want to parse through the code pasted below, the simple flow is:

1. On Salesforce1, create a Printer Message using a little step-by-step process governed by a controller in Apex (here).
2. Wait for messages on the Streaming API, send them to handleOctoPrintCall and store the message’s original SFDC ID (below).
3. Determine if we need a GET or a POST, create the outbound request and send it to OctoPrint. OctoPrint then sends it to the printer.  Note that OctoPrint and this script are running on the same Raspberry Pi.
4. When the results come back, get the original message ID, and update the original request using a custom Apex REST service (here).

That’s is.

function handleOctoPrintCall(command, body) {
	var options;
  if (body == null) {
    console.log("body is null");
    options = {
	    url: OctoPrintURL + command,
	    headers: {
           	'X-Api-Key': OctoPrintApiKey
    	    }
	   };
   } else {
      console.log("body isn't null");
     options = {
      url: OctoPrintURL + command,
      method: "POST",
      body: body,
      headers: {
            'X-Api-Key': OctoPrintApiKey,
            'Content-Type': 'application/json'
          }
      };
 
   }
 
	request(options, callback);
}
 
function callback(error, response, body) {
  console.log("callback from printer");
  console.log(body);
  console.log("end callback from printer");
  
  if (!error && response.statusCode == 200) {
    console.log(body);
    sendPrinterResponse(body);
  } else if (!error && response.statusCode == 204) {
    console.log("Empty Body (204)");
    sendPrinterResponse( JSON.stringify({ "result" : "OK" }) );
  }
 
}
 
function sendPrinterResponse(body) {
 
  var newBody = {
    originalId : lastMessageId,
    responseJson : body
  };
 
  var options = {
      url: orgOauth.instance_url + '/services/apexrest/PrinterResponse',
      method: "POST",
      body: JSON.stringify(newBody),
      headers: {
            'Authorization': 'OAuth ' + orgOauth.access_token,
            "Content-Type": 'application/json'
          }
    };  
 
  request(options, printerResponseCallback);  
 
}
 
function printerResponseCallback(error, response, body) {
  console.log('printerResponseCallback');
  lastMessageId = '';
  if (!error) {
    console.log("success");
    console.log(body); 
  } else { 
    console.log("error");
    console.log(error);
  }
}

The other bits of code in the gist are relatively mundane — a heartbeat so I know the system is alive, OAuth magic with salesforce (thanks Kevin et al!)

Practical Applications

The most frequent question people ask me when I tie together a few interesting bits of technology is simple: why? That’s a great question, and sometimes I’m doing it just to demonstrate that it’s possible. 3D printing and Salesforce is different.

One practical (but abstract) application  of an integration like this is to check asset utilization.  The more expensive, specialized equipment you have, the more likely you are to care about it’s utilization.  In general, the more you utilize these assets, the better.  The classic example here is Southwest Airlines and their drive to turn their planes around very quickly. The more often their planes are flying, the more money they’re making.  All of these assets and this data should be surfaced through whatever interface your team is likely to use in service of this goal.

More concretely, let’s say you have a 3D printer farm at your company, and you use those printers to create parts.  Maybe these are R&D parts, maybe they’re spare parts, maybe they’re promotional chochkies.  Having something to spawn jobs and monitor progress is a good thing.  More than that, having a source of engineered, iterated on and blessed 3D designs means that users are more likely to get the results they want.  A central resource like the one I’ve shown here is a step in the right direction.

If you take this idea one level further, let’s saying you have a very interesting service scenario where a piece of equipment reports a system fault automatically.  That fault is then diagnosed as needing a unique spare part, which is 3D printed and then automatically delivered by, for example, a quadcopter.  That’s some next generation stuff right there.

There are more ideas, but you get my general train of thought here.

Things That Went Wrong Along the Way

Lots of things went wrong and didn’t work.

1. Most irritatingly, I accidentally aborted printing this super-cool T-Rex skull.  Totally blaming Seligman but it’s my fault for wanting to show him another project.  ProTip: think before you unplug that USB. Hours of printing and meters of filament down the drain.
2. I wanted to get out of the Streaming API pattern and connected OctoPrint directly to the Internet.  No reason that shouldn’t work, except my attempts at using VyperVPN and No-Ip to get that going failed, failed and failed again.  Killed a whole day.  Someone better at networking could do it. The Streaming API is dead easy because I don’t have to worry about open a port on my network, etc.
3. Turns out 3D printers are relatively hard to get.  I somehow caught a window where I could buy these on Amazon.  The first two that arrived were all busted up like someone had dropped them off a pretty tall conveyor, but replacements were only a couple days away.  Lots of places advertise filament and printers and neglect to mention a 6 week lead time and even on Amazon these are now a 2-4 week delivery item.
4. At one point, I jammed the feed on the printer so bad I had to call in backup.  Gory details over on their forum. Turned into a great excuse to take apart the printer though and I always like that.
5. The PrintrBot Simple intro video made some mention of the various kinds of surface treatments you could use to enhance your printing.  The standard is blue painters tape–it works like a charm!  I also tried some beige masking tape I had lying around the house, since The blue stuff was a Home Depot away, and it was an unmitigated disaster.

Wrap Up

Over all, I end where I started: this stuff is super cool.  But it’s also still pretty new and not very polished yet.  If you jump in now, you’ll need to be patient and interested in tinkering.  And if you are those things — WOW.  You’re going to love it!