Solidoodle Spool Mount
This is now on thingiverse as Garage door roller Solidoodle spool mount.
I'm seeing irregular places in the prints that might mean a clog, or might mean I'm trying to push too much filament through the hot end, or might mean the filament is too hard to pull off the spool and through the hole in the back of the solidoodle.
I certainly need to check all of these things, but the simplest to check was making a print while I manually turned the spool to make sure the filament was always slack. Since the print quality got better (not perfect, just quite a lot better), I decided I needed a low friction spool mount as one part of the solution, so I concieved the idea of using ball bearing garage door rollers, which are easy to obtain even if you don't happen to have a robot hobby parts supplier down the street (most of us don't :-).
The plan is to print some sleeves for the roller stems that will center them in a 3/4 inch PVC pipe, and a wheel well for the rollers to sit in on top of some supports.
Here's the primary openscad library that defines all the modules used to print the parts:
// I need easier to feed filament to avoid problems with extruder not being
// able to drag in the filament. This is a new spool mount design (with bits
// lifted from other designs) using (relatively) easy to obtain garage door
// opener rollers.
//
// As step 1 I got a couple of ball bearing rollers with a nylon roller
// around a steel bearing. A little light machine oil loosened up the
// somewhat thick grease and let them roll much more freely. Gonna print
// some disks that will center the rollers in a PCV pipe and some other
// disks that will center the spool around the pipe so the whole thing
// should turn easily.
// Global parameters for tuning model:
// Diameter of the steel stem shafts on the rollers.
//
stemdiameter = 11.11 + 0.5;
// Inside diameter of the PVC pipe (pipe used is 3/4 inch PVC which is small
// enough to fit through the holes in both my solidoodle and octave spools
// of filament).
//
pipeinside = 20.57 - 0.5;
// Spacer thickness (want it long enough to prevent rattling and hold
// stems securely).
//
spacerthick = pipeinside;
// Largest diameter of the rollers
//
rollerdia = 46.21 + 0.5;
// Thickness of the rollers
//
rollerthick = 12.4 + 0.5;
// diameter to allow clearance for the shaft in the mounting block
//
shaftspace = 24;
// extra length to use for the shaft so it will be wider than the mounting block
// when we subtract it off.
//
shaftextra = 20;
// blockwalls is the thickness of the walls to make in the mounting block
//
blockwalls = 2;
// Fiddle with these parameters to get a grid that fits nicely around the
// wheel well.
//
gridthick = 2;
gridskip = 4.2*gridthick;
gridcount = 20;
// These are the dimensions of the various spools I want to allow for
// Outer diameter of the PVC pipe I need to slide the spool supports over
//
pvc_outer_diameter = 26.9; // That was largest I found - it varied a bit
// The diameter of the whole spool (supports need to be high enough for this).
//
solidoodle_spool_diameter = 5 * 25.4; // 5 inches
// The solidoodle spool has a "stepped" hole with a smaller hole centered in
// a bigger hole.
//
solidoodle_small_diameter = 39.10;
// This is the size of larger hole.
//
solidoodle_big_diameter = 45.25;
// This is the depth of the "step" from larger hole down to smaller hole
//
solidoodle_step_depth = 8.75; // also varied a bit, this was deepest.
// Diameter of whole octave spool (bigger than solidoodle).
//
octave_spool_diameter = 6.25 * 25.4; // 6 1/4 inches
// Diameter of octave spool hole (only 1 to deal with on octave spool)
//
octave_small_diameter = 31.78; // (that was largest number I got)
ic3d_small_diameter = 52;
// PART 1: Two inner spacers each get epoxied to the shafts of the garage
// door rollers, which then allow the rollers to slide into the 3/4 inch PVC
// so it can rotate freely.
//
module innerspacer() {
difference() {
cylinder(r=(pipeinside/2), h=spacerthick);
translate([0,0,-1])
cylinder(r=(stemdiameter/2), h=spacerthick+2);
}
}
// rollerwheel forms a solid shaped like a wheel on the garage door roller.
// I have parameters to pass so you I can make different sizes.
//
module rollerwheel(dia, thick) {
union() {
rotate_extrude(convexity = 10)
translate([dia/2-(thick/2), 0, 0])
circle(r = (thick/2));
translate([0,0,-(thick/2)])
cylinder(r=0.1+((dia/2)-(thick/2)), h=thick);
}
}
// hollowheel makes a bigger than normal rollerwheel and subtracts the size
// wheel we really want from it then cuts thethe top half off the
// wheel. This gives us the shape for the block that will go on top of the
// mount to hold the wheels where the spool will rotate.
//
module hollowheel() {
// move whole thing up above Z instead of all below Z.
translate([0,0,(rollerdia+(blockwalls*2))/2])
// Rotate into printable position.
rotate([90,0,0])
difference() {
// big wheel
rollerwheel(rollerdia+(blockwalls*2), rollerthick+(blockwalls*2));
// subtract small wheel from inside
rollerwheel(rollerdia, rollerthick);
// subtract top half of the whole thing.
translate([-((1+rollerdia+(blockwalls*2))/2),0,
-((1+rollerthick+(blockwalls*2))/2)])
cube([1+rollerdia+(blockwalls*2),
1+rollerdia+(blockwalls*2),
1+rollerthick+(blockwalls*2)]);
}
}
// blockgrid is a 45 degree oriented grid I can cut the rest of the block
// out of (reduce plastic used, help prevent warping, etc).
//
module blockgrid() {
translate([-((gridcount * gridskip)/2),0,0])
union() {
for ( i = [0 : gridskip : gridcount * gridskip]) {
translate([i, 0, 0])
rotate([0,0,45])
translate([-(rollerdia/2), -(blockwalls/2), 0])
cube([rollerdia, blockwalls, rollerdia]);
}
for ( i = [0 : gridskip : gridcount * gridskip]) {
translate([i, 0, 0])
rotate([0,0,-45])
translate([-(rollerdia/2), -(blockwalls/2), 0])
cube([rollerdia, blockwalls, rollerdia]);
}
}
}
// PART 2: This is the mounting block with the well the roller wheel fits
// in. Two of these are needed, one for the top of each side of the spool
// mount.
//
module mountingblock() {
difference() {
union() {
difference() {
intersection() {
// Start with big old grid
blockgrid();
// Intersect with cube the size of the mounting block
translate([-(rollerdia+(blockwalls*2))/2,
-(rollerthick+(blockwalls*2))/2,0])
cube([rollerdia+(blockwalls*2),rollerthick+(blockwalls*2),
(rollerdia+(blockwalls*2))/2]);
}
// Subtract off space for the roller wheel
translate([0,0,0.1+(((rollerdia+(blockwalls*2))-0.1)/2)])
rotate([90,0,0])
rollerwheel((rollerdia+(blockwalls*2))-0.1,
(rollerthick+(blockwalls*2))-0.1);
}
// Add back in the hollow roller wheel well
hollowheel();
}
// subtract space for wheel shaft
translate([0,(rollerthick+shaftextra)/2,(rollerdia+(blockwalls*2))/2])
rotate([90,0,0])
cylinder(r=(shaftspace/2),h=rollerthick+shaftextra);
}
}
// PART 3: Sleve for PVC pipe with ever increasing diameter rings to fit in
// various spool hole to hold the spool centered on pipe.
//
module spoolsleeve() {
difference() {
union() {
cylinder(r=(octave_small_diameter-0.5)/2, h = 20);
cylinder(r=(solidoodle_small_diameter-0.5)/2, h = 15);
cylinder(r=(solidoodle_big_diameter-0.5)/2, h = 10);
}
translate([0,0,-1])
cylinder(r=(pvc_outer_diameter+0.5)/2,22);
}
}
// The holes in an ic3d spool are enormous. Make a separate sleeve for it.
//
module ic3dsleeve() {
difference() {
union() {
cylinder(r=((ic3d_small_diameter+3)/2), h=3, $fn=128);
cylinder(r=(ic3d_small_diameter/2), h=17, $fn=128);
}
translate([0,0,-1])
cylinder(r=(pvc_outer_diameter+0.5)/2, h=22, $fn=128);
}
}
// Now I need to build the supports that hold the whole thing up by at least the
// radius of the largest spool of filament I'm likely to use. I'll want a platform
// at the top where I can glue in the mountingblocks.
// PART 4: Mounting bracket for outside edge of solidoodle. Cut from the
// netfabb cloud fixed version of thingverse thing 97734. Need two of these.
//
module outerbracket() {
intersection() {
translate([-38.18,148.96,0])
import("Brackets_fixed.stl");
translate([-1,0,-1])
cube([100,42,100]);
}
}
// PART 5: Mounting bracket for inside edge of solidoodle. Cut from the
// netfabb cloud fixed version of thingverse thing 97734. Need two of these.
//
module innerbracket() {
translate([-0.50,-2.27,0])
intersection() {
translate([-38.18,148.96-43,0])
import("Brackets_fixed.stl");
translate([-1,0,-1])
cube([100,42,100]);
}
}
// Now modify the left hand support from the fixed version of thingverse
// thing 97734 by cutting off the top and replacing it with a platform where
// I'll glue the wheel wells.
well_x = rollerdia+(blockwalls*2);
well_z = rollerthick+(blockwalls*2);
well_y = (rollerdia+(blockwalls*2))/2;
extra_x = 8.6; // extend platform by this much to merge with support strut.
// Use netfabb to pick off these dimensions from existing model.
//
support_y = 142;
support_x = 99.15;
support_clip = 38.74;
platform_dim = 4; // How thick do I want the platform I'm adding?
// PART 6: Left side support.
//
module leftsupport() {
union() {
intersection() {
translate([-109.92,147.79,0])
import("Leftupright_fixed.stl");
cube([100,support_y + platform_dim - well_y,100]);
}
translate([support_x - ((well_x/2) + (support_clip/2) + extra_x),
support_y - well_y, 0])
cube([well_x+extra_x+platform_dim, platform_dim, well_z+platform_dim]);
translate([support_x - ((well_x/2) + (support_clip/2)),
support_y + platform_dim - well_y, 0])
cube([well_x+platform_dim,platform_dim,platform_dim]);
translate([support_x +well_x - ((well_x/2) + (support_clip/2)),
support_y + platform_dim - well_y, 0])
cube([platform_dim,platform_dim,well_z+platform_dim]);
}
}
// PART 7: Right side support.
//
module rightsupport() {
mirror([1,0,0])
leftsupport();
}
// I haven't printed this, but in theory it adds some stiffness to the
// supports, making them a bit thicker and curving out at top and
// bottom for more support.
module support_slice() {
intersection() {
leftsupport();
cube([89.03,116.64+0.1,5.08]);
}
}
stiffthick=6.9;
stiffrad=(20.9-stiffthick);
module stiffcyl(ytran) {
translate([-1,ytran,stiffthick+stiffrad])
rotate([0,90,0])
cylinder(h = 100, r = stiffrad);
}
// Union with leftsupport() to make stiffer left support (mirror for right
// support).
//
module stiffner() {
difference() {
intersection() {
union() {
support_slice();
translate([0,0,5]) support_slice();
translate([0,0,10]) support_slice();
translate([0,0,15]) support_slice();
translate([0,0,20]) support_slice();
}
cube([89.03,116.64+0.1,20.90]);
}
stiffcyl(116.64-stiffrad);
stiffcyl(10.04+stiffrad);
translate([-1,10.04+stiffrad,stiffthick])
cube([90,(116.64-10.04)-2*stiffrad,20.90]);
}
}
You can download the complete set of openscad files as well as the STL files from spool2.tar.bz2.
Here's what the printed parts look like:
You can see how the rollers fit in the wells:
And how the PVC fits over the rollers:
This isn't part of my design files, but I'll need a couple of these: coconnor55's Tension Nut for 3/4" PVC Pipe, so I printed one (and switched to blue filament out of curiosity to see if it worked any differently than the black) and it seems to work perfectly right off the printer:
It is difficult enough to move that it should keep the spool centered, but it isn't too hard to move if you push firmly.
I've also designed and printed (because it was another really simple model) the sleeves to fit over the PVC pipe that provide different diameter rings to fit in different brand spools (solidoodle and octave are what I have at the moment):
For my vertical supports, I plan to steal as much as possible from gsterley's Solidoodle Spool Holder Mk2 (but I seem to need to repair all the parts with netfabb Cloud Service before I can import them into openscad).
This was the largest part I ever printed, and it was a nightmare to get it to stick to the bed. I finally resorted to hairspray plus acetone and ABS slurry, and got it to print (then the big challenge was getting it off the glass bed — you can still see patches of dried slurry clinging to it :-).
Now I just have to get it to work one more time for the right side support, then print the brackets (shouldn't be as difficult since they are smaller), and I can get it mounted on the printer.
Well, the right support is being a pain in the patoot as well, but I did get one set of brackets printed so I have enough parts to try the left side now:
After readjusting the print bed level, finding that the glass seems flatter if I clip it front and back rather than left and right, fixing the z-stop, and starting with a fresh coat of AquaNet, I finally got the right support to print reasonably well (slight curl at the top just as it finished - I simply filed the curl straight rather than reprinting). I also rotated the STL 90 degrees since it would have come too close to the clips on the glass bed otherwise.
(I should probably punch some ovals through the top wheel well platform to try and keep it from wanting to curl up so much.)
After all those adventures, I got the wheel wells glued to the tops of the supports and some 6-32 screw threads tapped into the holes in the support and was able to assemble everything:
It can wobble a bit from side to side if you push it (perhaps a slightly stiffer support would be better), but as long as the printer doesn't happen to hit the resonant frequency, it should be OK :-).
If I do have a problem with wobbling, I've designed this stiffer version:
Now I need to hack up a new top for the case. I figure I'll probably just cover the spool and everything (if I continue to use foamboard, it will be light enough, but a little clumsy to put on and take off when changing filament).
And here's the new top in two pieces. The back fits inside the spool mount and is fairly permanently attached. The front slips over the back and just lifts off:
Overall, it has a kind of industrial feel :-).
Go back to my main Solidoodle page.