I found some nice micro servos on ebay:

These servos not only are tiny, they are also cheap. I bought 3 of them for 4 Euros a piece.

I started to redesign the printed parts of the z-probe prototype. But compared to these micro servos, the mechanical construction was huge. Too huge!

After thinking about this for a while, I found a solution: Keep it simple!

Here’s what I came up with:

It’s basically just the servo with an opto endstop pcb glued to it…

Its smaller, it’s simpler, it’s adjustable and it works great.

Here’s a how to build the probe:

I also simplified the z-probe firmware, based on the latest G3Firmware. Since the firmware now natively supports servos (for the Unicorn pen plotter), I was able to reduce the code patches to just a few lines for the z-probe commands.

Unfortunately I wasn’t able to update my forked firmware repository on GITHub. I’m (still) really uncomfortable with using git! Each time, it’s a pain in the ass to merge new revisions from the remote repository with my forked repositories (locally and/or on GITHub). I’m pretty sure, that this is supposed to be easy, but there always are problems, errors or conflicts. And I’m still looking for a good tutorial for these hacker tasks…

Anyway, until I’m in the mood to check out git again, here are the few code changes necessary to support the z-probe in the newest firmware revision:

v2/src/shared/Commands.hh:
105 105 #define SLAVE_CMD_GET_SP			32
106 106 #define SLAVE_CMD_GET_PLATFORM_SP		33
107 107
    108+#define SLAVE_CMD_ENGAGE_Z_PROBE		128
    109+
108 110 #endif // SHARED_COMMANDS_H_

v2/src/Extruder/Host.hh:
18 18 #ifndef HOST_HH_
19 19 #define HOST_HH_
20 20
   21+// ZProbe settings
   22+// 750ms
   23+#define ZPROBE_TIMEOUTINTERVAL ((micros_t)750000L)
   24+
   25+// Angles in Degree
   26+#define Z_PROBE_ENGAGE_ANGLE  0
   27+#define Z_PROBE_DISENGAGE_ANGLE 50
   28+
21 29 void runHostSlice();

v2/src/Extruder/Host.cc:
149 149 			to_host.append8(RC_OK);
150 150 			return true;
    151+		case SLAVE_CMD_ENGAGE_Z_PROBE:
    152+			{
    153+				uint8_t angle = ((bool)from_host.read8(2))?Z_PROBE_ENGAGE_ANGLE:Z_PROBE_DISENGAGE_ANGLE;
    154+				board.setServo(1,angle);
    155+				micros_t endDelay = board.getCurrentMicros()+ZPROBE_TIMEOUTINTERVAL;
    156+				while(board.getCurrentMicros()<endDelay); // Wait for Servo
    157+				board.setServo(1,-1); // Switch Servo off
    158+			}
    159+			to_host.append8(RC_OK);
    160+			return true;
151 161 		case SLAVE_CMD_GET_SP:
152 162 			to_host.append8(RC_OK);
153 163 			to_host.append16(board.getExtruderHeater().get_set_temperature());

The ReplicatorG patch can be also simplified (no more EEPROM preferences for the Z-Probe). But I didn’t find time for this yet. For the time beeing, you can simply use the patched version from here.

Well, I still have 2 servos left…

I wonder what I can do with one of these and a slightly modified version of this thing, directly glued to the servo arm. I’m pretty sure it’ll work just as fine as that thing, only with 16 parts less…

Keep it simple!

Since a while it rattles a lot during printing, so at least I wanted to remove the X/Y stages from the bot, in order to clean the rods and to tighten all bolts.

I also wanted to find a better solution for the heated build platform’s cables. Until now, they somehow dangled in the back of the Makerbot on their way up to the extruder controller board.

After removing the X/Y stage from the bot, I saw another problem which needed to be solved:

Not only the acrylic build surface looks like reaching its end of life (it’s still the very first one, which came with the Makerbot kit more than a year ago), the main problem is that the whole platform has far too much play. Although my heated build platform is rather heavy (6mm aluminum + 3 big power resistors), I remember that this was also a problem with the original, unheated, wooden build platform.

I decided to bolt the aluminum plate directly to the Y stage with one central screw:

In order to be able to easily remove the print stage, I got rid of the acrylic build platform (bolt to the aluminum plate before). Instead I tried three different “interface” sheets.

The first try was a aluminum cover for the build platform. I folded the cover out of .5mm aluminum sheet with Kapton tape as surface:

To cut a long story short: It didn’t work. The cover wasn’t easy to install and remove from the build platform and it was impossible to get a good, leveled surface.

Next, I tried a piece of transparent LDPE. I had some leftovers of this from building the second filament box. I attached the LDPE with some foldback clips to the heated build platform.

It worked relatively well. However, the LDPE degenerates rather quick:

Also I have the problem that there are only very few spots on the build platform where foldback clips can be used without blocking the build platform’s movement. Since LDPE heavily warps when heated, there just weren’t enough clips to hold it down to the flat aluminum.

Finally, I cut a sheet of thin glass (from a cheap picture frame) to 10x10cm. Like the aluminum sheet, I used Kapton tape as “interface” material for the ABS. So far, this build surface seems to work great. The glass is nicely flat and leveled and keeps it that way when heated. And two foldback clips are enough to securely attach the surface to the aluminum plate:

Now, with the aluminum platform bolt down to the y stage, I was able to use a piece of ribbon cable to connect the cables from the platform with the x stage:

There was a connector on one end of the ribbon cable (it used to be a part of an old PC’s RS232 access), I glued this end of the cable to the y stage. After soldering a compatible connector to the platform’s wires, I was able to connect the heated build platform in a way which allows easy removal if needed.

Up until half way, I glued the ribbon cable to the x stage’s edge. Then the cable runs inside the drag spring from the x stage to the outside of the Makerbot. I already had the drag spring installed about a year ago to guide the y stepper motor’s and the y end stops’ cables.

Here’s a short video of the ribbon cable during a print:

It works great!

After playing around with my Mendel for a while, I very much like the autohoming feature of it’s firmware.

When I browsed the current Makerbot firmware, I was surprised to find support for automatic homing, ready to use. As far as I know, this code is currently not used by ReplicatorG, right?

Anyway, having endstops installed for the X and Y stage, it’s no problem to autohome these stages with the current firmware.

Just send the G-Codes G28, G161 or G162 with information on the axis to the Makerbot:

G28 is the “normal” ‘return to home’ G-code, also used by the RepRap firmware. However, in the Makerbot firmware, there are two more variants of the homing functions:

G161 is ‘home negative’, which means, that the respective stages are moved in direction of the MIN endstop until they reach the end of the line. Currently, G28 and G161 are exactly the same in the Makerbot firmware.

G162 is ‘home positive’, which means, that the respective stages are moved in direction of the MAX endstop until they reach the end of the line.

Concerning the X and Y stage, you might use either of them to bring the Makerbot into a “well known position”. If you have installed all four MIN/MAX endstops for the X&Y stages, that is.

In case you have only one endstop per axis you should call G161 for those axes with a MIN endstop and G162 for those axes with a MAX endstop.

My Makerbot, for example, has only one endstop per axis: MAX on the X axis, MIN on the Y and Z axes. So in order to home my Makerbot, I’d send

G162 X
G161 Y Z

The Z-axis endstop isn’t as easy to install as the X/Y endstops. Depending on the build platform and/or extruder or frostruder you’re using, the Z-axis endstop needs to be adjusted for the correct height.

Quite a while ago, I already tried some possible solutions on my Makerbot. Back then, I designed the Z-stage endstop trigger (my very first published thing on Thingiverse!). I also designed  a X-stage endstop trigger and an adjustable Z-stage endstop trigger. But since I wasn’t too happy with the results, I never published these.

I always thought, that the best way to do homing of the z-stage would be a probe as near as possible to the nozzle, sensing the actual build surface.

I also did some test on this back a year ago, but again the results weren’t too promising:

The main problem is, that the probe needs to be retractable during the print process. A year ago I tried to solve this with a manual retraction mechanism. But it didn’t work reliably. Also, adjusting the probe wasn’t very easy.

More than a year later, I learned a lot about electronics, microcontrollers and embedded systems programming…

So here’s what I came up with:

The Z-Probe

This new design contains a standard endstop PCB and a needle-like sensing-probe. The head of the sensor is motorized retractable with help of a standard servo.

The Z-Probe is designed to be mounted behind/under the extruder on the z-stage:

That way, the Z-Probe is able to sense the build platform only 1-2 cm from the nossle.

The servo, lowering and rising the sense-pin, is controlled by the extruder controller board. There are two digital pins on the extruder controller board v2.2, currently unused on a Makerbot (D9 and D10).

These pins are ready to use with a servo. Just plug the servo connector to the 3 pins of D9. Make sure to put the black wire (GND) on the pin marked with “-”:

Of course, some firmware/host software changes are needed in order to drive the Z-Probe.

The D9 and D10 pins are even PWM enabled. So usually it’s quite easy to add support for servos on an Arduino controller.

Unfortunately, since v2 of the extruder controller firmware Adam from Makerbot Inc. decided to move away from the Arduino IDE and API. The firmware is now “native AVR”, i.e. no more access to the Arduino libraries. Of course, there are several valid reasons to abandon the Arduino IDE, especially when projects grow and get more complex. But this also makes it harder  to “hack” the software.

What’s even worse: The current firmware already uses the hardware timer of the ATMega, which ususally drives the PWM pins D9 and D10. So I needed quite a while to understand how to solve these problems.

I think, I’ve found a way to solve the problem with the timer. The current firmware uses this timer for a general software interrupt routine. So I hooked the servo driver for the z-probe into the same interrupt routine.  So the servo PWM signal now is created by the CPU in software (and not by the hardware PWM driver). I tried some other ways around this timer conflict, but this was the only way both, the servo and the rest of the firmware, are working. I guess it’s not the best idea to mess around with one of the firmware’s central timers…

After solving these problems, I was able to extend the firmware with a new class “ZProbe”. This class handles the lowering and raising of the ZProbe hardware.

The upper and lower positions of the ZProbe are configurable in the extruder’s EEPROM preferences (well, they will be, as soon as I’ll find the bug which currently prevents the firmware to write new values to the preferences…).

In order to control the Z-Probe from within Replicator-G and -even more important- from within G-Code files, I added some new “M-Codes” to the GCode-Parser: M140, M141 and M142

M140 “Engage Z-Probe”: This M-Code lowers the Z-Probe into working position.

M141 “Disengage Z-Probe”: This M-Code raises the Z-Probe into parking position.

M142 “Adjust Z-Proble Angle”: This M-Code takes a S argument and moves the Z-Probe’s servo int the given angle (e.g. M142 S45 moves the servo to 45°). This code is intended for internal use only.

One thing to keep in mind is, that the zeroed Z-stage with engaged Z-Probe mustn’t be moved in X or Y direction. Since the Z-Probe pin touches the build surface in this case, moving the build platform could cause scratches in the build surface or -worse- damage of the Z-Probe itself. So always either disengage the Z-Probe or raise the Z-stage a little before moving the X/Y stage.

Here’s the G-Code for a complete autohome sequence on a Z-Probe equipped Makerbot:

G21 (Metric FTW)
G91 (relative positioning)
G0 Z7.0 (move up the z-stage for security)
M141 (Disengage Z-Probe)
G90 (Absolute Positioning)
G162 X (home positive)
G161 Y (home negative)
G92 X0 Y0 (Reset reference position)
G0 X-55.0 Y20.0 (Center ** Z-Probe-Pin **)
G92 X0 Y-25 (Reset reference position)
M140 (Engage Z-Probe)
G161 Z F500 (home negative [fast])
G92 Z0 (Reset reference position)
G0 Z2.0 (Back up z-stage 2mm)
G161 Z F25 (home negative [slow])
G92 Z0 (Reset reference position)
M141 (Disengage Z-Probe)
G1 F150 (Reset Z-speed)
G0 Z1 (backup Z for Y move)
G0 Y0 (center Y *** Nozzle ***)
G0 Z0 (return Z to zero)

Of course, this G-Code would need to be adjusted if the Makerbot has an other endstop configuration than mine. Also the ‘move to center’ distance is likely different on each Makerbot.

Here’s a video, showing my Makerbot while running the above G-Code:

As you can see, the Z-Probe just works, even if the height of the build platform was changed. No manual adjustmens needed. This is not only a nice feature for operators using differnt types of build platforms or surfaces, it also might be quite useful for people using the brand new Automated Build Platform.

You want?

First and frontmost: This is all still in a very early stage, both hardware and software.

I released the printable parts for the Z-Probe on Thingiverse: http://www.thingiverse.com/thing:4093

The design is for use with a Futaba servo S148. That’s the servo I found in my junk box. I guess each servo has a different size. So the design might be more a draft for your own design. I plan to try the same thing with a smaller (and cheaper) “micro servo” in the future. I hope I’ll find the time to create a parametric OpenSCAD design until then.

Since it’s still a prototype, the servo is currently glued to the base plate with some hot glue.

Both, the new extruder firmware as well as the extended ReplicatorG host software, are available on GitHub. I forked both projects from Makerbot:

G3Firmware: http://github.com/zaggo/G3Firmware

ReplicatorG: http://github.com/zaggo/ReplicatorG (ZProbe branch)

Please remember: This is all beta (at best). As mentioned above there’s still a known bug with saving the Z-Probes EEPROM settings.

Feel free to improve!

With a second working 3d printer in the house, I needed an extra filament spindle box. It was easy enough to build the first one for my Makerbot, so why not build a second, improved one?

The most wanted improvement was a window.

It turns out, that it’s not only nice looking but sometimes also important to see what’s going on inside the box. So I changed the design slightly to sport a window on the front.

Since it turned out, that the second disk above the filament spool on the turntable isn’t really needed (the spindle’s construction is self-supporting and the box’s top keeps the filament on the spindle), I recycled the spare plywood disk in the second filament box: It got promoted to be the turntable. (If you don’t have an extra plywood disk at hand, see here how to cut the disk out of a rectangular sheet of plywood with a Dremel).

Needing even less wooden parts (no front side, no plywood for the turntable), the remaining material was even cheaper to get. Including the sheet of transparent plastic (“Hobby Glass”, a sheet of 2mm transparent LDPE, 25x50cm), the whole stuff cost me less than 5€ (!).

Here’s the updated part list for the box:

There were some requests for detailed drawings, so here you go:

(These drawings are also available as PDF. I added them to thing 3640 on thingiverse.com.)

The change in design is, that -instead of a front wall- there’s a groove for a sheet of transparent plastic (or acrylic, or glass, or whatever).

If you got a circular saw, the grooves are quite easy to make: Adjust the circular saw blade’s height to about half the MDF thickness (i.e. if you use 10mm MDF, adjust the saw to 5mm). Then use the saw’s stop to saw the groove 10mm from the front side of the bottom, top, left and right parts (I hope I’ve got the technical terms about right in English…).

If you don’t have a circular saw at hand (I don’t!), you might use a Dremel to cut the grooves. That’s slightly more work and probably not as exact, but it’s good enough:

After cutting the grooves and drilling all holes, the assembly of the box is quite easy. I used some glue for additional stability.

Then I did measure the final width of the front window (including the depth of the grooves).

Cutting the LDPE sheet was very easy: After slightly slitting the sheet with a box cutter, the sheet can be broken at a table’s edge. It’s like cutting glass, only with a knife and without the cullets.

Now I was able to mark the final height of the window:

Another LDPE-cut later, the box was almost finished:

I didn’t change the inner construction of the box. So all printed parts, ball bearings and rods are the same as in the first box.

I added one last improvement to the box’s turntable: Since the filament roll tends to loosen up a little bit on the turntable, it can happen that some loose filament “falls” from the turntable. That’s usually not a big problem, but it could lead to a turntable-jam.

To avoid that, I used some paper (160g/m²) to build kind of a “cake setting ring” around the turntable (maybe one could actually use a real cake setting ring for this?).

The paper ring catches the loose filament windings, but it doesn’t interfere with the unwinding mechanism itself.

jstitner on Thingiverse.com:

The HDPE tubing that is used on the makerbot looks the be the same as the “polyethylene” tubing used to connect refrigerators that have water dispensers.

I found a package with 10m LLDPE tubing in a store, selling refrigerators, washing mashines and stuff like that.

It’s a water tube (I guess some kind of spare part for a water dispenser) with an outer diameter of 6.5mm and an inner diameter of 4mm. Perfect!

Thanks again to jstiltner for the tip!

I already had drilled a hole for the filament into the side of the box:

Now that I had the actual tubing, I printed an object to attach it to the filament box:

Actually I printed two of them. On the one hand, the object prints better when printing two at the same time (the ABS has a hard time to cool down enough between layers when printing only one), on the other hand I used the second holder to mount a spring with about the same OD as the tubing on the inside of the box to flexibly guide the filament. Both parts are bolt down with one M4x20mm bolt:

The tubing (with the filament inside) then goes loosely to the top of the Makerbot. I use a guidance ring, I used before to keep the filament out of the timing belt on top of the Makerbot, to give the tubing some support on its way to the extruder:

I updated the Thingiverse.com thing with the printed parts and added the STL file for the tubing holder part.

I liked the the horizontal design of the “official” Makerbot filament spindle, so I decided to build my own filament spindle box based on (or rather inspired by) this open source design.

Since I don’t have access to a laser cutter, I re-designed the enclosure box for the filament spindle to be build from rectangular parts. It’s cheap and easy to buy custom pre-cut wood in almost any larger hardware store. I got the pre-cut wooden parts for less than 15€:

Here’s the part list for the wooden parts:

Qty	Size (mm)	Material
2	310 x 310	MDF 10mm
2	310 x 120	MDF 10mm
2	290 x 120	MDF 10mm
2	280 x 280	Plywood 4mm

I printed all smaller and more complex parts in ABS on the Makerbot. The STL files for these parts are published on Thingiverse: http://www.thingiverse.com/thing:3640

Finally the following non-printable parts are needed:

Qty	Part
1	M8 Threaded rod (approx. 135mm long)
2	608 Ball Bearing
2	M8 nut
2	M8 washer
4	M4 x 12mm bolts
6	M4 x 55mm bolts
16	M4 nuts
26	Chipboard screws (35mm)

The only non-printable parts (too big) in a non-rectangular shape are the two disks, holding the filament in place. I used my Dremel with its circle cut tool to cut the two square plywood sheets into (more or less) round shape. It was the first time I used the circle cutter and I learned a lot about how to not use it :) However, the disks are hidden inside the box anyway…

Building the box is straight forward: Pre-drill and countersink the holes for the chipboard screws (the hole for the axle in the center is a stepped bore 8/13mm. More on this later)…

… and assemble the box, using some glue and a bunch of chipboard screws:

(Well, I guess 3 screws per edge would have been more than enough…)

The axle inside the box is stationary. The lower M8 nut is counter-sunk on the “outside” of the box (that’s why the center hole is a stepped bore). Inside the box, the axle holds a sandwic containing a M8 washer, a 608 ball bearing, another washer and finally a second nut:

The 608 ball bearing holds the bottom plywood disk (and therefor the filament roll). I know, the ball bearing isn’t designed to hold load in axial direction. But the  approx. 2.5 kg shouldn’t be any problem for a 608 ball bearing (even in axial direction) and the spool turns rather slowly. According to wikipedia, the maximum axial load of a radial ball bearing is usually between 25 and 50% of it’s maximum radial load. And a 608 ball bearing is able to handle a static radial load of about 1400N (!)

The axle is cut to length, so the upper end should end “inside” the top cover (approx. 5mm):

The top cover plate also gets a center bore (8mm diam.), but only half way thru.

That way, the top cover plate hold the stationary axle centered.

To attach the bottom plywood disk to the 608 bearing, I printed an ABS bearing holder part:

This part is bolt to the plywood disk with four M4 bolts.

The 608 ball bearing should fit snugly:

(The 608 ball bearing in the photo above was only inserted to check its fit. Later, the ball bearing is already mounted on the axle as described above and the plywood disk (with the ABS bearing holder bolt to its lower side) is pressed onto the ball bearing on the axle.)

… back to the headline

Initially I planned to use the chipboard screws only for building the wooden box. But when designing the printable parts, I ran into an old problem: how to connect the printed parts with the non-printed parts? In case of the lower bearing holder it’s no problem to use bolts and nuts to attach it to the plywood disk. But in case of the inner distance parts it’s not that easy. Using the T-slot technique (normally used with laser cut assemblies) isn’t that easy with printed ABS parts. The T-slots likely aren’t printed with enough detail and ABS is probably too soft to hold the pressure from the tiny M3 or M4 nuts.

Finally it struck me: Why not simply use chipboard screws and screw them directly into the ABS? After all, when disassembling industrial plastic objects, you almost never find bolts and nuts but self-tapping screws. So why not use the same technique with printed objects? The design gets even simpler: just print the parts with “pre-drilled” bores for the screws and you’re ready to go. No captive nuts. No fiddling around.

Granted, some nice, black socket cap bolts with self-locking nylock nuts look usually much more elegant. Also parts you want to disassemble frequently are much better off with some kind of nut & bolt connection.

But all other connections are great candidates for “direct screwing” with chipboard screws. Chipboard screws are available in all kind of sizes and they are cheap!

That said, I designed the inner distance parts with a “pre-drilled”  bore for a 35mm chipboard screw, holding it on the plywood disk:

To hold the upper end of the inner distance parts in place, I designed a second ball bearing holder:

This second holder contains slots for six M4 bolts, used as spokes:

Since I put the Makerbot on top of the closed filament spindle box, there’s no need for any additional closing mechanism.

Things to do

As mentioned above, I still need to design and print some kind of snap-in mechanism for the upper plywood disk.

A much bigger problem is, that I still don’t have any tubing to guide the filament from the box’s outlet (a hole on the right side of the box) to the extruder. It’s harder than I thought to get hands on a small amounts of plastic tubing (at least around here in my hometown). In order to minimize friction, I guess the best material would be PTFE. So far I found PTFE tubing only in online stores in large quantities of 25 or 50m (which is quite expensive, especially since I need only 1 or 2m).

If someone knows a good, cheap source for PTFE tubing in small quantities (preferably in Germany), please let me know.

For the Mendel, I tried it again (with PLA this time). I cleaned the whole thing, rewound the nichrome wire and attached the extruder to a special variant of the Printruder II:

This Printruder II has a special mounting hole to directly screw the insulator-less extruder to the body with a single captive M8 nut.

Although the whole setup looked very nice and I even was able to extrude PLA at 185°C by pushing the filament manually, it got stuck again as soon as I tried to extrude more than 5cm with the motor.

I really don’t know why the extruder doesn’t work, but I guess the problem is the long brass barrel. Probably, the plastic melts way too early in the barrel and forms some kind of plug.

It seems I have to count the insulator-less extruder as a fail after all.

Speaking of fail: I finally recieved two new stepper motors: SY32STH47-1683B from Zapp Automation. This motor is recommended on the RepRap  site for use in the Mendel Extruder 2.0. However, after connecting it to a standard MakerBot extruder controller and trying to drive it with the MakerBot firmware (recompiled for driving a stepper extruder motor), it turned out that even when just driving the bare stepper motor (no gears, no filament, no nothing), both A3949 motor driver chips on the extruder board heat up to 70-100°C in just a few seconds and start to smell funny. The stepper motor turns as expected during this time, so I’m quite sure the 4 wires are connected in the correct order.

I switched of the whole thing quickly, so I’m not sure if 100°C is the top temperature or if the chips would just burn out (I really don’t want to know…).

Do I something wrong? When reading the Mendel documentation on the RepRap page, it looks like there is no additional electronics needed. Just hooking up the 4 stepper wires to the 1A/1B/2A/2B connectors on the extruder board and go.

When asking for help on the RepRap forum, nophead answered that I’d need to limit the current by using a smaller PWM value than 255. I tried that already, but the chips still get very (!) hot and if using a lower PWM value, the stepper motor looses a lot of its torque, of course.

Does anyone successfully use a stepper motor in an extruder with MakerBot firmware? I’d really appreciate any help on this.

But back to today’s main feature :)

The “Complextruder”

When reading about a “Concept for Extruder” in the Makerbot mailing list some days ago, I really liked the first illustration, Brent Crosby (“baxsie”) attached to his post:

This sketch shows a heater section where a PTFE tubing goes all the way down from the extruder body to shortly before the hot zone in the extruder tip. This should reduce friction in the extruder significantly. And since it seems, that too much friction killed my insulator-less extruder design, I decided to give this design a try.

Please also have a look at the “Concept for Extruder” mail thread in the MakerBot mailing list. Brent documents there the build process of a slightly different extruder design (derived from the above, but using a rather large melting chamber).

Here’s a drawing of what I try to build:

Although I used the general idea of Brent’s design, I changed it in order to get an extruder I could easily use with a standard MakerBot extruder body (and of course with a Printruder II).

To avoid leaking plastic, I designed the PTFE tubing to be threaded at the end where it goes into the brass hot part. This also makes the whole thing somehow more rigid.

The brass nozzle

Here’s the nozzle blank, before drilling the stepped bore:

The completed nozzle. Although out of focus, you can see the M6 threads inside the nozzle:

Another shot of the finished nozzle, this time in focus (kind of):

The PTFE tubing

I presume, that the PTFE tubing in Brent’s original design is meant to be a piece of simple PTFE tube. But since this part is slightly more complex in my design (and I don’t have any PTFE tubes lying around), I turned this from a piece of 15mm PTFE rod.

The outher PTFE shell

This part was rather easy to build. It’s simply a piece of 15mm PTFE rod with a 9mm bore in it:

Assembly

Once the three parts are manufactured, the assembly of the extruder is straight forward:

1. Screw the PTFE tubing into the end of the brass nozzle

2. Press the above part into the outer PTFE shell

3. Insert the holder

I build the holder (my version of the MakerBot Retainer Washer) from a 2mm thick piece of aluminum bar. The part has a centered 6mm hole for the nozzle and two 3mm holes for the M3 bolts (holding the whole thing on the extruder body). Using the aluminum bar instead of a large washer also allows you to use such an extruder nozzle in a standard Mendel carriage.

Finally, I wound the nichrome wire onto the brass nozzle:

And here’s the completed extruder nozzle, after attaching a thermistor and some insulated wires to the nichrome:

So far so good. I hadn’t a chance to test the new nozzle, yet.

I need to print another Printruder II first, since I don’t want to risk dissasembling my current (and only only working) extruder to test the new nozzle. I hope, I find the time to test it tomorrow.

I’ll let you know, as usual…

Nevertheless, I tried to simplify the design of the Printruder since a while for several reasons:

• Reducing the number of parts to print
• Easier loading/undloading of filament
• Easier adjustment of pinch pressure
• Stylish design : )

Here’s what I came up with:

The Printruder II

The Printruder II is built from only 2 printed parts (click on the images to zoom in):

• The Motor Block is now self-supporting, so no more base plate. I also integrated the insulator retainer plate. So instead of three printed parts in the Printruder, we now have only one:
  
  .
• The Idler Block is much smaller than the idler block in the first Printruder design. It’s now integrated inside the motor block. With this design, it’s now possible to press the idler wheel against the pinch wheel with only one bolt. This makes it very easy to load/unload the filament and also to adjust the gap between idler wheel and pinch wheel:
  
  .

Download the STL files for all printable parts at thingiverse.com: http://www.thingiverse.com/thing:1980

Intructions

Here’s what you need to build a Printruder II:

• Printed Motor Block^*)
• Printed Idler Block
• 3 x M3x20mm bolt
• 1 x M3x16mm bolt
• 1 x M4x40mm bolt
• 3 x M3 washer
• 1 x M4 nut
• 3 x M3 nut
• 6mm pipe or rod, 20mm long (alternatively a M6x20mm bolt)
• 2 x M6 washer
• 2 x 626 ball bearing
• Kysan DC Gear Motor
• MakerBot pinch wheel or better: 10mm worm-gear style pulley^*)
• MakerBot heater section
• Extruder controller board

Optional:

• Printed PCB holder (2 parts)
• 4 x M3x16mm bolts
• 4 x M4 nut

Most likely:

• Printed extruder holders

^{*) Please note that there are two slightly different versions of the motor block: one for the original timer belt pulley (pinch wheel) and one for the 10mm worm-gear style pulley. Be sure to print the correct one!}

Step 0:

Print all printed parts.

As always, it’s a good idea to clean all holes with a drilling machine (or something like that) after printing.

Step 1:

Insert a M3 nut in each hole in the bottom of the motor block (left and right of the filament path). These captive nuts are needed later to attach the heater section to the motor block. Handling the M3 nuts inside the motor block is a very fiddly thing. Also they tend to fall out when turning the motor block over later. Thus I strongly recommend to use (a little!) hot glue on the M3 nuts when inserting them. Don’t use too much glue! Just a little bit on the outside of the nut.

The best way to insert the nuts is to stick a long M3 bolt though the hole in the motor block (from the outside). Then put the nut on the bolt, apply a little bit of hot glue and then pull the bolt back until the nut sits nicely, all the way down, inside the hole. Wait a few seconds for the glue to set, then unscrew the bolt (see also this image).

Step 2:

Now assemble the idler wheel: Put a M6 washer, the 626 bearing and then the other M6 washer on the 6mm axis (I use a 20mm piece of 6mm aluminum pipe, but you might also use a M6x20mm bolt or something). Press this assembly into the printed idler block, so that the two M6 washers are inside the brackets, acting as spacers for the ball bearing. The axis should snap into the brackets and hold the bearing snugly inside the idler block.

Step 3:

Insert a M3 nut in the hole on the backside of the idler block. The nut’s only purpose is to give the M4 set screw (see later) some target to press on (the ABS plastic is too soft to hold the pressure alone). Then insert a M3x16mm bolt into the hole on the side of the idler block. This bolt, again, doesn’t hold something down, but simply stabilizes the M3 nut. That way, the M4 set screw cannot sink into the idler block later.

Step 4:

Insert the whole idler assembly in the motor block. Be sure, that the head of the M3x16mm bolt is on the front.

Step 5:

Put the M4 nut into the hole on the right side of the motor block. The best way to do this is to use the M4 bolt (same thing as for the M3 nuts in step 1). Only this time, you can let the M4 bolt where it is when finished. It also might be helpful to use some hot glue on the nut (just a little bit!).
Finally, move the insulator block to the right.

Step 5:

Attach the DC motor, including the pinch wheel, to the motor block.

Use three M3x20 bolts with M3 washers to bolt the motor to the motor block:

Tighten the bolts, but remember that the motor block is out of ABS plastic! Don’t overdo it…

Then put a 626 ball bearing on the end of the motor spindle. Be careful not to block the idler wheel with the motor’s 626 bearing! It’s probably not necessary to push the ball bearing all the way on the spindle. If needed, use a drop of hot glue to fix the ball bearing, but be careful not to glue down the ball bearing itself!

If you’re using a worm-gear style pinch wheel (what’s a good idea for several reasons), the motor’s ball bearing is probably not necessary, since worm-gear style pulleys usually need much less pressure from the idler wheel to grip the filament properly. Your milage may vary.

Step 6:

Attach the heater assembly (a new one or one cannibalized from a Mk3/Mk4 extruder) to the motor block, using the two M3 nuts from step 1.

Be careful not to push the captive nuts out of their holes!

Success:

That’s it, you built a Printruder II:

At least the non-optional part…

PCB holder:

Since it’s a nice thing to know where to put the extruder controller board, I designed an optional PCB holder for the Printruder II (and maybe other extruders). The PCB holder is composed of 2 printed parts:

Clip the front holder on the DC motor and move it towards the motor block.

Clip the other holder on the motor…

… and use 4 M3 bolts to attach the extruder controller to the PCB holder:

Using the Printruder II  with a MakerBot

Although the Printruder II can be mounted in a MakerBot with the original acrylic dinos, you’ll most likely end up with a nozzle too high, depending on the heater section (especially the heater barrel):

As you can see in the above picture, the nozzle is on about the same height as the lower end of the dinos. If this would be attached to the z stage, you’ll never get the nozzle low enough to touch the build stage.

Therefor I also designed printable replacements for the dinos. You find the designs on thingiverse.com: http://www.thingiverse.com/thing:1912

What’s the story with the worm-gear style pulleys?

The worm-gear style pinch wheels have much better grip than the timing belt pulleys, used in the original MK3/MK4 extruders. That’s why they don’t need so much pressure on the idler wheel, which not only gives the motor bearings some rest, but also results in much less damage to the filament (i.e. less need to floss the gears).

Unfortunately, there’s currently no way to buy worm-gear style pulleys anywhere (at least to my knowledge).

MakerBot Industries did some test with CNC manufactured worm-gear style pulleys. But I have no idea if they (still) plan to sell them in the MakerBot store and if yes, when.

I manufactured mine on my lathe:

Although I’m getting better (and faster) in building these pulleys, it’s still a lot manual labor involved (I don’t have a CNC lathe!).

Due to the time-consuming manual production:

1. these things ain’t cheap (25 Euro + tax (if applicable) + shipping)
2. when out of stock, I’m not sure when I have the time to built more.

The pulleys are made out of brass (outer diam. 10mm, inner diam. 6mm.) and they come with a M3 set screw.

If someone’s interested in one of these, please contact me (mail [att] pleasantsoftware [dot] com). I have a couple of them lying around as spares.

After breaking my trusty Printruder during my first .3mm nozzle tests, I had to reprint broken parts for the Printruder, which lead to a heated build surface, which lead to modifying the extruder firmware, which lead to integrating a I2C-LC display… After my recent tests with raftless printing, I eventually came back to the original project: the .3mm nozzle.

Since it was a bad idea last time to use my one-and-only Printruder for the nozzle tests, I started to design a new extruder for this purpose. My first tests with a stepper motor driven extruder weren’t too promising (… the lack of force it was able to push the filament with. Probably a design flaw of mine. I already started redesigning the whole thing, but this is yet another project…), I plan to drive the new extruder with tested and proven mechanics: Printruder motor/gear brackets and MakerBot DC gearmotor with a threaded pulley. For the heater section, I already started to build a PTFE/insulator free design a while ago. After a couple of drawbacks, I finally did a successful first heater test today.

The heater barrel is definitely inspired by nopheads extruder barrel designs:

But there are several differences:

1. I used brass instead of steel. This might be a disadvantage, since brass has a way higher heat conduction. But I only had brass rods laying around and I’m also not sure if it is more difficult to turn such part from steel. I suppose it mainly depends on the type of steel. So I stick with the metal I am currently used to, after all I’m still a greenhorn when it comes to working with a lathe…
2. I designed the barrel to hold a heat sink, since the Plastruder doesn’t contain any large aluminum parts I can use for this.
3. I still use nichrome wire to heat the nozzle.
4. The barrel has a M6 thread on one end in order to mount a standard MakerBot nozzle on it.

The thin part in the above photos is still 5mm in diameter since I was afraid to rupture the barrel (there’s a 3.5mm bore inside, you know…?).

But that was a real problem during my first heater test: Probably also due to the high heat conduction of the brass material, it was impossible to reach decent nozzle temperatures. Instead, the heat went straight to the heat sink and the upper end of the barrel.

So I disassembled the whole thing again and boldly turned an additional 1mm off the thin part. It’s now 4mm in diameter which means, that the wall thickness is only .25mm.

Here’s an image of the reworked heater section, right before the new temperature test:

Reducing the wall thickness did the trick!

It’s now quite fast and easy to reach ABS extruder target temperature (220°C).

I tested the setup for about 10 to 15 minutes. Here the results:

So far so good!

Now I need to print a special retainer plate to attach the heater section to a Printruder and eventually try to extrude some ABS…

It might take a few days since there are all this other projects… And to spice things up, I just printed my first part for a Mendel yesterday :)

Here’s another short movie of the display in action:

I cleaned up my modifications in the extruder controller firmware and pushed my changes to a branch on the makerbot/G3Firmware github repository. You find the modifications in the “zaggoLCD” branch.

Next up: Trying an alternative solution with the LCD connected to the motherboard’s I2C bus…

I tested this today for the first time: A LC-display on my MakerBot.

The display is connected via the I²C bus of the extruder controller:

The trim-pot is for the LCD’s contrast adjustment. The rest of the connection is pretty straight forward (4 wires: SDA, SCL, VCC & GND).

The display is a 4×20 alphanumeric LCD with a HD44780 controller. The I²C-to-8bit-parallel interfacing is handled by a I2C LC-Display Adapter, I ordered online for about 13€ + shipping.

The nice thing about I²C-interfacing is the easy wiring over the already available I²C-bus on the extruder controller board (or the motherboard…). No need for a bunch of Arduino pins…

I drive the LCD/I²C with a modified firmware on the extruder controller. The I²C is nicely supported by Arduino’s Wire library.

Since the main data I’m interested in is available on the extruder board (temperatures, extruder motor status), I decided to connect the LCD directly to the extruder controller (and not the motherboard). There are also 3 unused pins (2 digital, 1 analog) on the board for handling button input in the future. On the motherboard (v1.2) I only found one…

However, I ran into some unexpected problems when extending the extruder controller’s firmware: I ran out of memory!

The current firmware is only a few hundred bytes smaller than the available memory on the ATmega168 (about 14kB). I finally managed to install my modified firmware by disabling some unused code and libraries (unused at least by me). But I’m still only less then 100 bytes under the capacity of the controller which is definitely not good.

So I’ll have to move my mods over to the motherboard and try to transport the temperature and motor state data over the RS485 connection. Since this already makes problems when doing it for ReplicatorG (open control panel to read temperatures leads often to hangs during builds), I’m not sure if this will work…

Anyway: It’s fun to see the the LCD in action: