// 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]);
   }
}