The Smell of Molten Projects in the Morning
Ed Nisley's Blog: Shop notes, electronics, firmware, machinery, 3D printing, laser cuttery, and curiosities. Contents: 100% human thinking, 0% AI slop.
You know how, in those old cartoons, whenever the vultures started landing in nearby trees, that was an indication of trouble ahead for the hero?
The local Turkey Vulture flock has a roost a few miles away and they’re often seen circling in the thermals overhead.
A few years ago I encountered one dismantling a squirrel flapjack on the road:
It’s an ugly job, but somebody’s got to do it…
The prototype X Rod Follower turned out to be pretty good fit, after I filed a slot in the back for the belt clamp. The bearings wound up 1.5 mm too close to the centerline, but a pair of #4 washers on each post solved that problem. The tweaked OpenSCAD source below should produce a drop-in replacement.
It’s important to center the bearings on the rod, because they’re designed to support only radial loads. In a normal application the bearings live in a slip-fit pocket that supports the entire outer race, but here an off-center point contact applies an axial force and misaligns the bearing races. They can’t handle axial forces at all: you (well, I) can easily feel the difference an axial millimeter makes.
With the follower in place, the force required to move the beltless X stage dropped from 0.75 pounds to zero: the stage slides back and forth across the entire length of the rods with a finger tap! The mechanical overconstraint on rods simply Went Away, pretty much as I expected.
[Update: In case it’s not obvious from the picture, you must remove both bronze bushings from the front of the X stage when you install this Follower. Leave the back pair in place.]
After installing and tensioning the drive belt, the stage still requires about 1 pound = 0.5 kg = 5 N to push along the rods, but now there’s no mechanical binding at any point along the way. That’s with the motor unplugged from the driver; you don’t want to count the effort required to light the LEDs!
Now, to reassemble and realign the rest of the build platform again.
The OpenSCAD source has only a few dimension numbers changed from the previous version, but here it is in one cut-n-paste lump:
[Update: You should use carmiac’s version, which prints better. The original code says “rear guide rod follower” but it turned out to fit better on the front of the X stage.]
// Thing-O-Matic X Stage front guide rod follower
// Ed Nisley - KE4ZNU - Mar 2011
include </home/ed/Thing-O-Matic/lib/MCAD/units.scad>
Build = false; // set true to generate buildable layout
$fn = 8; // default for holes
// Extrusion values
// Use 2 extra shells behind the perimeter
// ... and 3 solid shells on the top & bottom
ThreadThickness = 0.33;
ThreadWT = 1.75;
ThreadWidth = ThreadThickness * ThreadWT;
HoleWindage = ThreadWidth; // enlarge hole dia by extrusion width
Protrusion = 0.1; // extend holes beyond surfaces for visibility
// Bearing dimensions
BearingOD = (3/8) * inch; // I used a hard-inch bearing -- try a 603 or 693
BearingID = (1/8) * inch;
BearingThick = (5/32) * inch;
BearingBoltDia = 3.0; // allow this to shrink: drill & tap the threads!
BearingBoltRadius = BearingBoltDia/2;
BearingStemOD = BearingBoltDia + 6*ThreadWidth;
BearingStemRadius = BearingStemOD/2;
BearingStemLength = 2.0;
// X guide rod dimensions
RodDia = (3/8) * inch; // hard inch rod
RodRadius = RodDia/2;
RodLength = 75; // for display convenience
RodClearTop = 12.6; // clearance from HBP to rod
RodClearSide = 9.7; // ... idler to rod
RodClearBottom = 10.7; // ... rod to Y stage
RodClearCirc = 1.5; // ... around circumference
// Drive mounting piece (from ABP teardown)
DriveHolesX = 16.0; // on-center distance
DriveHolesZ = 9.0; // on-center distance
DriveHoleZOffset = -5.0; // below bottom of HBP platform
DriveHeight = 28.0;
DriveBoltDia = 3.0 + HoleWindage; // bolt dia to hold follower in place
DriveBoltRadius = DriveBoltDia/2;
DriveBoltHeadDia = 6.0 + HoleWindage;
DriveBoltHeadRadius = DriveBoltHeadDia/2;
DriveBoltWeb = 4.5; // leave this on block for 12 mm bolts
HBPNutDia = 4.0; // HBP mounting nut in middle of idler
HBPNutRadius = HBPNutDia/2;
HBPNutRecess = 0.5; // ... pocket for corner of nut
HBPNutZOffset = -10.0; // ... below bottom of HBP platform
BeltWidth = 7.0; // drive belt slots
BeltThick = 1.2; // ... backing only, without teeth
BeltZOffset = -22.5; // ... below bottom of HBP platform
// Bearing locations
Preload = 0.0; // positive to add pressure on lower bearing
TopZ = RodRadius + BearingOD/2;
BottomZ = Preload - TopZ;
// Follower dimensions
BlockWidth = 28.0; // along X axis, must clear bolts in idler
BlockHeight = RodDia + 2*BearingOD - Preload;
BlockThick = (RodClearSide + RodRadius) - BearingThick/2 - BearingStemLength;
BlockHeightPad = RodClearTop - BearingOD;
echo(str("Block Height: ",BlockHeight));
echo(str("Block Height Pad: ",BlockHeightPad));
echo(str("Block Thick: ",BlockThick));
BottomPlateWidth = 10.0;
BottomPlateThick = 5.0;
BlockTop = RodRadius + RodClearTop;
BlockOffset = BlockThick/2 + BearingStemLength + BearingThick/2;
echo(str("Drive wall to rod center: ",BlockThick + BearingStemLength + BearingThick/2));
// Construct the follower block with
module Follower() {
difference() {
union() {
translate([0,BlockOffset,0])
difference() {
union(){
cube([BlockWidth,BlockThick,BlockHeight],center=true);
translate([0,0,(BlockHeight + BlockHeightPad)/2])
cube([BlockWidth,BlockThick,BlockHeightPad],center=true);
}
for(x=[-1,1]) for(z=[0,1])
translate([x*DriveHolesX/2,
Protrusion/2,
(BlockHeight/2 + BlockHeightPad + DriveHoleZOffset - z*DriveHolesZ)])
rotate([90,0,0])
cylinder(r=DriveBoltRadius,
h=(BlockThick + Protrusion),
center=true);
for(x=[-1,1]) for(z=[0,1])
translate([x*DriveHolesX/2,
(-(DriveBoltWeb + Protrusion)/2),
(BlockHeight/2 + BlockHeightPad + DriveHoleZOffset - z*DriveHolesZ)])
rotate([90,0,0])
cylinder(r=DriveBoltHeadRadius,
h=(BlockThick - DriveBoltWeb + Protrusion),
center=true);
translate([0,
((BlockThick - BeltThick + Protrusion)/2),
(BlockHeight/2 + BlockHeightPad + BeltZOffset)])
cube([(BlockWidth + 2*Protrusion),
(BeltThick + Protrusion),
BeltWidth],center=true);
}
translate([0,BearingStemLength/2 + BearingThick/2,TopZ])
rotate([90,0,0])
cylinder(r=BearingStemRadius,h=BearingStemLength,center=true,$fn=10);
translate([0,BearingStemLength/2 + BearingThick/2,BottomZ])
rotate([90,0,0])
cylinder(r=BearingStemRadius,h=BearingStemLength,center=true,$fn=10);
}
translate([0,(BlockOffset - BearingStemLength/2),TopZ])
rotate([90,0,0])
cylinder(r=BearingBoltRadius,
h=(BlockThick + BearingStemLength + 2*Protrusion),
center=true);
translate([0,(BlockOffset - BearingStemLength/2),BottomZ])
rotate([90,0,0])
cylinder(r=BearingBoltRadius,
h=(BlockThick + BearingStemLength + 2*Protrusion),
center=true);
translate([0,
(BlockThick + BearingStemLength + BearingThick/2 - (HBPNutRecess - Protrusion)/2),
(BlockHeightPad + BlockHeight/2 + HBPNutZOffset)])
rotate([90,0,0])
cylinder(r=HBPNutRadius,h=(HBPNutRecess + Protrusion),center=true);
rotate([0,90,0])
cylinder(r=(RodRadius + RodClearCirc),h=RodLength,center=true,$fn=32);
}
}
// Arrange things for construction
if (Build)
translate([0,(-BlockHeightPad/2),(BlockOffset + BlockThick/2)])
rotate([-90,0,0])
Follower();
// Arrange things for convenient inspection
if (!Build) {
Follower();
translate([0,0,TopZ])
rotate([90,0,0])
#cylinder(r=BearingOD/2,h=BearingThick,center=true,$fn=32);
translate([0,0,BottomZ])
rotate([90,0,0])
#cylinder(r=BearingOD/2,h=BearingThick,center=true,$fn=32);
rotate([0,90,0])
#cylinder(r=RodDia/2,h=RodLength,center=true,$fn=32);
}
The extrusion settings, more or less, kinda-sorta, for the latest objects:
Wouldn’t it be great if you could export all that stuff to a text file in a readable format? The CSV files come close, but they’re not really meant for human consumption.
Subject to revision, your mileage may vary, past performance is no indication of future yield, perfectly safe when used exactly as directed, shake before using, don’t touch that dial!
A close look at the first few layers of some recent objects shows why I’m willing to put up with all the hassle described over the last few weeks.
For small objects, take a look at my build of coasterman’s calibration set:
Microscope LED ring light (two pieces glued on the obvious line):
Fan adapter plate:
Companion cube, with a slightly warped right corner:
Now, those objects may have other problems, but two things work really well:
What’s important to me: this is dependable and repeatable.
It’s not yet a simple routine, because these objects were built while I was hacking away at the HBP + aluminum plate platform, some are on the old ABP + aluminum plate arrangement, and they’re not all first-attempt parts. However, given a proper setup, It. Just. Works.
Part of the process involves a very slow first-layer feed: about 10 mm/s. At that pace the molten ABS has enough time to bond with the layer on the plate, even around corners; much faster and it can pull free.
The Extruder runs at 210 °C, the HBP at 120 °C, feed is 40 mm/s, and traverse is around 50 mm/s.
It is yet to be seen if this lashup will remain stable, but the first indications seem pretty good.
My intent with the modified HBP and removable aluminum build plate: get a stable, repeatable first layer height. That is where it all starts…
The thin(ner) aluminum plate clamped to the Heater establishes the overall platform alignment. The G-Code routine at the bottom probes the height at nine locations across the plate, with me shoving a taper gage under the nozzle at each spot and writing down what I read. The accuracy seems to be around ±0.05 mm (pretty much / sorta kinda), based on the spread-out scale on the gage and a good feel for when the gage touches the nozzle.
The results in mm above the sub-platform, after leveling the HBP with the adjusting bolts:
| 3.5 | 3.4 | 3.3 |
| 3.5 | 3.5 | 3.4 |
| 3.4 | 3.5 | 3.6 |
The 3.6 mm in the front right comes from the wiper hitting the Thermal Core insulation. I must trim that thing a bit!
Apart from that, it’s as flat and level as you could possibly want.
Measuring identical Outline extrusions with a max Z height = 116.5 mm and a 0.33 mm layer thickness on the three build plates produces these numbers, with units of 0.01 mm to save some typing:
| Plate 1 | ||||
| 42 | 38 | 35 | ||
| 43 | 31 | |||
| 43 | 33 | |||
| 38 | 34 | |||
| 37 | 33 | 32 | ||
| Plate 2 | ||||
| 37 | 33 | 31 | ||
| 35 | 23 | |||
| 33 | 21 | |||
| 25 | 15 | |||
| 19 | 16 | 17 | ||
| Plate 3 | ||||
| 38 | 30 | 29 | ||
| 37 | 28 | |||
| 34 | 27 | |||
| 32 | 31 | |||
| 28 | 29 | 28 |
Plate 2 may have trapped a bit of grit underneath the near edge; sometimes the dissolved ABS oozes around the edge or down a bolt head clearance hole to the underside, despite my best efforts.
Apart from that, they’re about as flat and level as you could possibly want from a loose plate sitting atop a moving platform. While the difference between a 0.43 and a 0.31 mm layer is visibly obvious, I don’t know how to get the plate any more level than that… at least without an entirely different and much heavier mechanical structure.
The real question comes down to repeatability: will the platform behave the same way under each extrusion, day in and day out, without requiring height adjustment for every object?
I know a bit about tool height probing, but it’s not clear attaching a Z-minimum limit switch to the side of the HBP, perhaps under the Heater, would track the top surface of the plate with sufficient accuracy. I don’t like touching the nozzle to the build plate itself, because either one may have an insulating layer of ABS or a bit of grit or whatever that would prevent electrical contact. Ditto for optical sensing, which depends on not having any snot hanging from the nozzle.
It’s definitely true that the platform height depends strongly on the HBP temperature. As nearly as I can tell, the build platform rises by about 0.5 mm as the Heater stabilizes the plates at 120 °C.
More numbers to follow, as they accumulate.
The height probing routine, in which you must set a suitable Z height for your very own machine:
(Measure surface flatness) (MakerBot Thing-O-Matic with ABP and aluminum plate) (Tweaked for TOM 286) (Ed Nisley - KE4ZNU - Mar 2011) (-- The usual setup --) G21 (set units to mm) G90 (set positioning to absolute) (**** home axes ****) G162 Z F1500 (home Z to get nozzle out of danger zone) G161 Y F4000 (retract Y to get X out of front opening) G161 X F4000 (now safe to home X) G92 X-53.0 Y-59.0 (set XY coordinate zeros) G92 Z116.5 (set Z for HBP with aluminum sheet platform) G0 X0 Y0 Z5.0 (-- Begin probing --) G1 Z1.0 (center) G4 P9000 G0 Z5.0 G0 X-40.0 (left center) G1 Z1.0 G4 P9000 G0 Z5.0 G0 Y-50.0 (left front) G1 Z1.0 G4 P9000 G0 Z5.0 G0 X0.0 (mid front) G1 Z1.0 G4 P9000 G0 Z5.0 G0 X40.0 (right front) G1 Z1.0 G4 P9000 G0 Z5.0 G0 Y0.0 (right center) G1 Z1.0 G4 P9000 G0 Z5.0 G0 Y50.0 (right rear) G1 Z1.0 G4 P9000 G0 Z5.0 G0 X0.0 (mid rear) G1 Z1.0 G4 P9000 G0 Z5.0 G0 X-40.0 (left rear) G1 Z1.0 G4 P9000 G0 Z5.0 G0 X0.0 Y0.0 (center again) G1 Z1.0 G4 P9000 (G0 Z5)
The Skeinforge Outline plugin draws a rectangle around the first perimeter layer of an object. I use that single-width, single-layer extrusion to monitor the height of the nozzle above the build platform and the tilt of the plate. The Outline extrusion will either peel off separately or come off as the film peels away from the plate when I twist the object off.
These Outlines come from a variety of objects. The one in the lower left was a test case that I stopped after extruding only the Outline.
I measure the Outline along each edge; larger objects provide three data points along each side of the build platform.
The good part of this is that it reports the build platform’s behavior during an actual extrusion, so you can keep an eye on whether it’s drifting out of alignment. The aluminum plates present a sufficiently flat surface that any variations will be due to a non-level HBP or an off-calibration Z-axis.
These numbers from around a large Outline told me that I should tweak the Z axis height down by 0.1 mm to increase the first layer thickness back to about 0.33 mm. The lower-right corner was slightly thicker because the wiper hit the Thermal Core insulation.
| 0.24 | 0.22 | 0.17 | ||
| 0.27 | 0.17 | |||
| 0.27 | 0.22 | |||
| 0.28 | 0.32 | |||
| 0.22 | 0.21 | 0.24 |
Given those values, I can tweak the leveling screws to adjust the platform tilt. What I don’t have at this point is any long-term record of how consistent my hacked HBP will be. But at least I’ve got numbers!
Printing ABS objects on an ABS film atop a heated aluminum plate works just about as perfectly as I could want, as witness those calibration objects. It turns out that the thickness of the ABS film makes a big difference in how well the first layer bonds to it.
I’m coating the plates with scrap ABS objects dissolved in MEK, because MEK seems to be less aggressively flammable than acetone. It smells horrible, though, and spreading a layer of toxic gunk with the consistency of honey can’t possibly be good for me. I use dead credit cards as spreaders and wonder if there’s a better way; a brush would clog up almost instantly.
The rough rule of thumb:
A Companion Cube growing out of a good pink film layer:
Peeling a smaller Cube off a plate shows how well it bonds to clear film. Notice how the film peels off the build plate without leaving any residue except for a tear in the film covering the hollow underside of the Cube.
These outline extrusions show the effect of a too-thin film, where the extrusion simply peeled off the film. Where it’s thick enough, the extrusion is welded right to the surface. Intermediate thicknesses tend to rip on both sides of the extrusion.
In round numbers, the perfectly formed film at the lower left is between 0.05 mm (the darker regions) and 0.09 mm (the deepest pink). The others range from 0.02 mm to 0.05 mm and are too thin for good bonding. Even the thickest film doesn’t add much to the first layer thickness.
The other part of the secret is extruding the first layer at 10 mm/s, which is 25% of the 40 mm/s I use for the rest of the object layers. The platform is at 120 °C, the Thermal Core at 210 °C, and the extrusion sticks like it’s welded… which, in fact, it is.
I think that a too-thin film cools the extrusion before it can bond with the film, while a just-right film melts slightly on contact. Extruding at 10 mm/s guarantees enough contact time for the filament to melt the film and cool down before the nozzle puts any tension on it: corners come out perfectly.
The other part of the puzzle requires an absolutely level build platform at a constant height from the nozzle. The platform leveling described there helps, but it’s a hassle to get everything set up.
The Smell of Molten Projects in the Morning 