// New Dial Indicator mount for the somewhat weird extruder assembly
// on my solidoodle.
//
// My extruder definitely appears to be different that some of the other
// ones folks have made mounts for. I have acrylic all the way around my hot
// end where it goes through the wood piece and I have 4-40 bolts in
// "backwards" from earlier extruders.

// Global parameters

// The width of the extruder jigsaw acrylic I'm going to be sitting on.
// Also the width of most of the parts of this dial mount.
//
mountwidth = 50;

// The amount to "explode" the parts by in the exploded view.
//
explode = 3;


// ******************************************************************* top plate
//
// Part 1: "tp" - top plate. The mounting plate to go above the wood piece
// on my extruder. Need 1 of these.
//
// This plate goes above the wood piece and fit on my extruder so it can be
// screwed onto the bits of 4-40 bolts that stick out on the bottom two
// bolts that go through the jigsaw.

// The width of the acrylic to the right side of the left bottom screw
//
tpright = 8.5;

// The width of the acrylic to the left side of the right bottom screw.
//
tpleft = 11.3;

// The diameter of the plate openings for the 4-40 screws and nuts.
//
tpholedia = 8;

// The height of the plate as it sits on the wood.
//
tpheight = 10.3;

// tpmiddle is the depth (from front of wood to front of acrylic) of the
// acrylic around the top of the hotend in the middle of the top plate.
//
tpmiddle = 3;

// tpside is the depth of the acrylic on each side of the plate (the side
// acrylic is set back farther than the middle).
//
tpside = 4.4;

module topplate() {
   difference() {
      union() {
         cube([mountwidth,tpheight,tpmiddle]);
         cube([tpright+(tpholedia/2),tpheight,tpside]);
         translate([(mountwidth-tpleft)-(tpholedia/2),0,0])
            cube([tpleft+(tpholedia/2),tpheight,tpside]);
      }
      translate([tpright+(tpholedia/2),(tpholedia/2),0])
         cylinder(h=(tpside+1),r=(tpholedia/2));
      translate([mountwidth-(tpleft+(tpholedia/2)),(tpholedia/2),0])
         cylinder(h=(tpside+1),r=(tpholedia/2));
      translate([tpright+(tpholedia/4),0,0])
         cube([tpholedia-(tpholedia/4),(tpholedia/2),(tpside+1)]);
      translate([mountwidth-(tpleft+tpholedia),0,0])
         cube([tpholedia-(tpholedia/4),(tpholedia/2),(tpside+1)]);
   }
}


// ********************************************************************* hex nut
//
// Part 2: "hn" - hex nut. The small cylinders to hold the 4-40 hex nuts
// that screw on the ends of the bolts sticking out of the extruder (and hold
// the whole thing on). Need 2 of these.

// Measure width of 4-40 nut flat side to flat side (and add any slop
// you think you might need to be able to fit the nut in the printed part).
//
hnwidth = 6.5;

// Measure thickness of the 4-40 nut.
//
hnthick = 2.5;

// hndia is the diameter of the cylinder that holds the nut.
//
hndia = 10;

// hntop is the thickness of the top layer of plastic "above" the nut.
//
hntop = 2;

// hncylthick is the thickness of the trap cylinder
//
hncylthick = hntop+hnthick;

// hnhole is the diameter of the small center hole
//
hnhole = 3;

module hncutout() {
   intersection() {
      translate([-hnwidth,-(hnwidth/2),0])
         cube([hnwidth*2,hnwidth,hnthick]);

      rotate([0,0,60])
         translate([-hnwidth,-(hnwidth/2),0])
            cube([hnwidth*2,hnwidth,hnthick]);

      rotate([0,0,120])
         translate([-hnwidth,-(hnwidth/2),0])
            cube([hnwidth*2,hnwidth,hnthick]);
   }
}

module hexnut() {
   difference() {
      translate([0,0,-hntop]) cylinder(r=(hndia/2), h=hncylthick);
      hncutout();
      translate([0,0,-(hntop+1)]) cylinder(r=(hnhole/2),h=(hntop+1));
   }
}

// ****************************************************************** nut handle
//
// Part 3: "nh" - nut handle. Glued to the hexnut piece to provide a handle
// to use when screwing the nut on the bolt end. Need 2 of these.

// height (or length depending on direction you are looking) of handle.
//
nhheight = 8;

// diameter of handle.
//
nhdia = 6;

// Tiny cone shaped "nub" on end of handle fits the hole in the hexnut piece
// for easy centering when gluing in place.
//
nhnubdia1 = hnhole-0.2;
nhnubdia2 = 2;
nhnubheight = 2;

module handle() {
   union() {
      cylinder(r=(nhdia/2),h=nhheight);
      translate([0,0,nhheight-0.1])
         cylinder(r1=(nhnubdia1/2),r2=(nhnubdia2/2),height=nhnubheight);
   }
}

// **************************************************************** bottom plate
//
// Part 4: "bp" - bottom plate. Glues onto the top plate to wrap around the
// wood piece and provide part of the holes where the hexnuts will be
// trapped as well as some stubs where the piece with the hole the dial
// indicator goes in can be glued. Need 1 of these.

// The thickness of the wood piece plus a little slop.
//
bpwood = 5.05;

// The vertical thickness of the lip that goes under the wood.
//
bpvertlip = 3;

// The depth of the lip on each side (more room under the wood on the
// sides than in the middle).
//
bpside = 7;

// The depth of the lip in the center (where these is less room and we
// don't want to jam into the extruder).
//
bpcenter = 3;

// The thickness of the bottom plate.
//
bpthick = 4;

// The diameter of the trap holes the hexnuts will fit in.
//
bptrapdia = hndia+2;

// The size of the "nubs" for guiding the gluing of the guage hole.
//
bpnubsize = 5;

// The distance the nubs should be from the edges of the plate.
//
bpnuboff = 3;

module bpstruct() {
   union() {
      cube([mountwidth,bpthick,tpheight+bpwood+bpvertlip]);
      cube([tpleft,bpthick+bpside,bpvertlip]);
      translate([mountwidth-tpright,0,0])
         cube([tpright,bpthick+bpside,bpvertlip]);
      cube([mountwidth,bpthick+bpcenter,bpvertlip]);
      translate([bpnuboff,-(bpnubsize-1),0])
         cube([bpnubsize,bpnubsize,bpnubsize]);
      translate([mountwidth-(bpnuboff+bpnubsize),-(bpnubsize-1),0])
         cube([bpnubsize,bpnubsize,bpnubsize]);
   }
}

module bphole() {
   translate([0,bpthick+1,bpwood+bpvertlip+(tpholedia/2)])
      rotate([90,0,0])
         union() {
            cylinder(h=bpthick+1,r=(bptrapdia/2));
            translate([-(bptrapdia/2),0,0])
               cube([bptrapdia,tpheight,bpthick+2]);
         }
}

module bottomplate() {
   difference() {
      bpstruct();
      translate([tpleft+(tpholedia/2),0,0])
         bphole();
      translate([mountwidth-(tpright+(tpholedia/2)),0,0])
         bphole();
   }
}

// ******************************************************************** nut trap
//
// Part 5: "nt" - nut trap. The remaining bits of the trap for the hexnut
// pieces, glues onto the bottomplate with the handles sticking through the
// homes. Need 2 of these.

// Inner diameter of cylinder that traps the nuts.
//
ntinnerdia = bptrapdia;

// Outer diameter of same.
//
ntouterdia = ntinnerdia+2;

// Space required for screws to travel while being screwed or unscrewed
//
ntinnerheight = 2;

// Outer height of the nut trap.
//
ntouterheight = ntinnerheight + 1;

module nuttrap() {
   difference() {
      union() {
         cylinder(r=(ntouterdia/2), h=ntouterheight);
         translate([-((ntinnerdia-1)/2),0,0])
            cube([ntinnerdia-1,(tpheight-(tpholedia/2))+1,ntouterheight+2]);
         translate([-((ntouterdia+4)/2),tpheight-(tpholedia/2),0])
            cube([ntouterdia+4,2,ntouterheight+2]);
      }
      translate([0,0,ntouterheight-ntinnerheight])
         cylinder(r=(ntinnerdia/2), h=ntinnerheight+2);
      translate([0,0,-1])
         cylinder(r=((nhdia+2)/2),h=ntouterheight+2);
   }
}

// ****************************************************************** guage hole
//
// Part 6: "gh" - guage hole. The part that glues on the very bottom and
// has the mounting hole for the dial indicator.

// The amount of clearance I need between the mounting hole and the rest
// of the mount (make sure the back of the guage is clear of the handles on
// the hexnuts).
//
ghclear = 10;

// The outer diameter around the hole that hols the dial guage.
//
ghouterdia = 20;

// How long is the hole the guage runs through.
//
ghthick = 15;

// Inner diameter of the hole. Needs to have a little slop to make sure the
// guage will fit in the printed part.
//
ghinnerdia = 10.33;

// How thick is the back of the plate.
//
ghback = 7;

// How wide is the notch in the back of the plate.
//
ghnotchw = 3;

// How high is the notch in the back of the plate.
//
ghnotchh = 4;

// How big a diameter hole to use for cutout in the back that make room for
// the extruder nozzle to fit.
//
ghnozdia = 40;

// How far into the back should the nozzle hole sink?
//
ghnozsink = ghnotchw;

// How far from the side of the back plate should the nozzle cutout be centered?
//
ghnozcen = 23;

// How far up should the nozzle cutout go?
//
ghnozhigh = ghthick+ghnotchw - (ghnotchh + 1);

module ghbackhole() {
   union() {
      difference() {
         cube([mountwidth,ghback,ghthick+ghnotchw]);
         translate([0,ghnotchh,(ghthick+ghnotchw)-ghnotchh])
            cube([mountwidth,bpnubsize,bpnubsize]);
         translate([bpnuboff-0.1,0,(ghthick+ghnotchw)-ghnotchh])
            cube([bpnubsize+0.2,bpnubsize,bpnubsize]);
         translate([mountwidth-(bpnuboff+bpnubsize+0.1),
                   0,(ghthick+ghnotchw)-ghnotchh])
            cube([bpnubsize+0.2,bpnubsize,bpnubsize]);
         translate([ghnozcen,((ghnozdia/2)+ghback)-ghnozsink,0])
            cylinder(r=(ghnozdia/2),h=ghnozhigh);
      }
      translate([0,ghback-0.01,ghnozhigh+0.01])
         rotate([-90,0,0])
            rotate([0,90,0])
               linear_extrude(height=mountwidth)
                  polygon(points=[[0,0], [ghnotchw,ghnotchw], [ghnotchw, 0]]);
   }
}

module mountinghole() {
   difference() {
      union() {
         cylinder(h=ghthick,r=(ghouterdia/2));
         translate([-(ghouterdia/2),0,0])
            cube([ghouterdia,1+ghclear+(ghinnerdia/2),ghthick]);
         translate([-(mountwidth/2),ghclear+(ghinnerdia/2),0])
            ghbackhole();
      }
      cylinder(h=ghthick,r=(ghinnerdia/2));
   }
}

// *************************************************************** exploded view
//
// Don't print this, just look at it :-).

module exploded_view() {
   union() {
      rotate([90,0,0])
         union() {
            topplate();
            translate([tpright+(tpholedia/2),(tpholedia/2),-(hnthick+explode)])
               hexnut();
            translate([mountwidth-(tpleft+(tpholedia/2)),
                       (tpholedia/2),-(hnthick+explode)])
               hexnut();
            translate([tpright+(tpholedia/2),
                       (tpholedia/2),-(hnthick+nhheight+3*explode)])
               handle();
            translate([mountwidth-(tpleft+(tpholedia/2)),
                       (tpholedia/2),-(hnthick+nhheight+3*explode)])
               handle();
            translate([tpright+(tpholedia/2),
                       (tpholedia/2),-(hnthick+nhheight+5*explode)])
               nuttrap();
            translate([mountwidth-(tpleft+(tpholedia/2)),
                       (tpholedia/2),-(hnthick+nhheight+5*explode)])
               nuttrap();
         }
      translate([mountwidth,bpthick+explode,-(bpwood+bpvertlip)])
         rotate([0,0,180]) bottomplate();
      translate([mountwidth/2,
                 (ghinnerdia/2)+ghclear+explode+bpthick+(ghback-ghnotchw),
                 -(bpwood+bpvertlip+ghthick+ghnotchw+explode)])
         rotate([0,0,180]) mountinghole();
   }
}