Design chromebook upcycle wall display mount

bookends/pantograph-bookend-model_files/bookend.scad

@@ -0,0 +1,185 @@
+/* PANTOGRAPH BOOKEND */
+
+side_width = 100;
+side_height = 150;
+thickness = 2;
+bar_width = 15;
+hole_diameter = bar_width/2;
+thread_tolerance = 0.05;
+threaded_pins = true;
+
+translate([0, -bar_width, 0])
+    left_wall2();
+right_wall();
+//bars(10);
+//pins(17);
+
+
+
+/******************************************************************/
+include <polyScrewThread_r1.scad>
+$fn=180;
+max=1000; //some high number for diff purposes
+hd=hole_diameter;
+bw=bar_width;
+sw=side_width;
+sh=side_height;
+t=thickness;
+tr=0.85;
+
+module pins(count) {
+    //2 long pins
+    translate([-3*bw,bw,0]) pin(true);
+    translate([-3*bw,2*bw,0]) pin(true);
+    
+    //rest are short pins
+    for(i=[3:count])
+        translate([-3*bw,bw*i,0]) pin(false);
+
+    //spacers        
+    for(i=[-1:2:1])
+        translate([-3*bw+i*bw/2*1.1,0,t/2]) spacer();
+}
+
+module spacer() {
+    difference() {
+        cylinder(h=t, d=bw, center=true);
+        cylinder(h=max, d=hd, center=true);
+    }
+}
+
+module pin(long) {
+    height = (long?3:2)*t+1;
+    translate([-bw/2,0,0]) pin_male(height);
+    translate([bw/2,0,0]) pin_female(height); 
+}
+
+module pin_female(height) {
+    if(threaded_pins) {
+        translate([0,0,.5]) cylinder(h=1, r=bw/2.5, center=true, $fn=6);
+        translate([0,0,1]) 
+        difference() {
+            translate([0,0,height/2]) cylinder(h=height, d=hd*.95, center=true);
+            translate([0,0, height+1]) rotate([180,0,0]) screw_thread(hd*tr, 3, 65, height+1, PI/8, 1);
+        }
+    }
+    else {
+        difference() {
+            translate([0,0,1.5]) cylinder(h=3, r=bw/2.5, center=true);
+            translate([0,0,3]) cylinder(h=4, d=hd*.97, center=true);
+        }
+    }
+}
+
+module pin_male(height) {
+    if(threaded_pins) {
+        translate([0,0,.5]) cylinder(h=1, r=bw/2.5, center=true, $fn=6);
+        translate([0,0,1]) screw_thread(hd*(tr-thread_tolerance), 3, 65, height, PI/8, 1);
+    }
+    else {
+        translate([0,0,.5]) cylinder(h=1, r=bw/2.5, center=true);
+        translate([0,0,(height+2)/2+1]) cylinder(h=height+2, d=hd*.95, center=true);
+    }
+
+}
+
+module bars(count) {
+    for(i=[1:count])
+        translate([bw+1.2*bw*i,0,0]) bar();
+}
+
+module bar() {
+    difference() {
+        plate(bw, sh-bw);
+        translate([0, sh/2-bw,0]) 
+        difference() {
+            translate([0,max/2,0]) cube([max,max,10], center=true);
+            cylinder(h=max, d=bar_width, center=true);
+        }
+        translate([0, -sh/2+bw,0]) 
+        difference() {
+            translate([0,-max/2,0]) cube([max,max,10], center=true);
+            cylinder(h=max, d=bar_width, center=true);
+        }
+        translate([0,(sh-2*bw)/2,0]) cylinder(h=max, d=hd, center=true);
+        translate([0,0,0]) cylinder(h=max, d=hd, center=true);
+        translate([0,-(sh-2*bw)/2,0]) cylinder(h=max, d=hd, center=true);
+    }
+}
+
+module right_wall() {
+    translate([-10,0,0]) mirror([1,0,0]) left_wall();
+}
+
+module left_wall() {
+    //side wall
+    translate([0,0,side_width/2]) 
+    rotate([0,270,0]) 
+    difference() {
+        plate(side_width, side_height);
+        translate([-(side_height-side_width)/2,0,0]) 
+        difference() {
+            translate([500,500,0]) cube([1000,1000,10], center=true);
+            cylinder(h=1000, d=side_height, center=true);
+        }
+    }
+
+    //back
+    translate([bw/2,0,0]) 
+    difference() {
+        plate(bw, sh);
+        translate([0, (side_height - bar_width)/2,0]) 
+        difference() {
+            translate([max/2,max/2,0]) cube([max,max,10], center=true);
+            cylinder(h=max, d=bar_width, center=true);
+        }
+        translate([0,(sh-bw)/2,0]) cylinder(h=max, d=hd, center=true);
+        translate([0,(sh-bw)/2-bw,0]) cylinder(h=max, d=hd, center=true);
+        translate([0,-bw/2,0]) cube([hd, sh-2*bw, 100],center=true);
+        translate([0,-(sh-bw)/2,0]) cylinder(h=max, d=hd, center=true);
+    }
+
+    //bottom
+    translate([bar_width/2,-side_height/2+thickness,side_width/2]) 
+    rotate([90,0,0]) 
+    plate(bar_width, side_width);
+}
+
+module left_wall2() {
+    //side wall
+    translate([0,0,side_width/2]) 
+    rotate([0,270,0]) 
+    difference() {
+        plate(side_width, side_height);
+        translate([-(side_height-side_width)/2,0,0]) 
+        difference() {
+            translate([500,500,0]) cube([1000,1000,10], center=true);
+            cylinder(h=1000, d=side_height, center=true);
+        }
+    }
+
+    //back
+    translate([bw/2,0,0]) 
+    difference() {
+        plate(bw, sh);
+        translate([0, (side_height - bar_width)/2,0]) 
+        difference() {
+            translate([max/2,max/2,0]) cube([max,max,10], center=true);
+            cylinder(h=max, d=bar_width, center=true);
+        }
+        translate([0,(sh-bw)/2,0]) cylinder(h=max, d=hd, center=true);
+        translate([0,(sh-bw)/2-bw,0]) cylinder(h=max, d=hd, center=true);
+        translate([0,-bw/2,0]) cube([hd, sh-2*bw, 100],center=true);
+        translate([0,-(sh-bw)/2,0]) cylinder(h=max, d=hd, center=true);
+    }
+
+    //bottom
+    translate([-bar_width,-side_height/2+thickness,side_width/2]) 
+    rotate([90,0,0]) 
+    plate(bar_width * 4, side_width);
+}
+
+
+module plate(width,height) {
+    translate([0,0,thickness/2]) cube([width, height, thickness], true);
+}

bookends/pantograph-bookend-model_files/polyScrewThread_r1.scad

@@ -0,0 +1,233 @@
+/*
+ *    polyScrewThread_r1.scad    by aubenc @ Thingiverse
+ *
+ * This script contains the library modules that can be used to generate
+ * threaded rods, screws and nuts.
+ *
+ * http://www.thingiverse.com/thing:8796
+ *
+ * CC Public Domain
+ */
+
+module screw_thread(od,st,lf0,lt,rs,cs)
+{
+    or=od/2;
+    ir=or-st/2*cos(lf0)/sin(lf0);
+    pf=2*PI*or;
+    sn=floor(pf/rs);
+    lfxy=360/sn;
+    ttn=round(lt/st+1);
+    zt=st/sn;
+
+    intersection()
+    {
+        if (cs >= -1)
+        {
+           thread_shape(cs,lt,or,ir,sn,st);
+        }
+
+        full_thread(ttn,st,sn,zt,lfxy,or,ir);
+    }
+}
+
+module hex_nut(df,hg,sth,clf,cod,crs)
+{
+
+    difference()
+    {
+        hex_head(hg,df);
+
+        hex_countersink_ends(sth/2,cod,clf,crs,hg);
+
+        screw_thread(cod,sth,clf,hg,crs,-2);
+    }
+}
+
+
+module hex_screw(od,st,lf0,lt,rs,cs,df,hg,ntl,ntd)
+{
+    ntr=od/2-(st/2)*cos(lf0)/sin(lf0);
+
+    union()
+    {
+        hex_head(hg,df);
+
+        translate([0,0,hg])
+        if ( ntl == 0 )
+        {
+            cylinder(h=0.01, r=ntr, center=true);
+        }
+        else
+        {
+            if ( ntd == -1 )
+            {
+                cylinder(h=ntl+0.01, r=ntr, $fn=floor(od*PI/rs), center=false);
+            }
+            else if ( ntd == 0 )
+            {
+                union()
+                {
+                    cylinder(h=ntl-st/2,
+                             r=od/2, $fn=floor(od*PI/rs), center=false);
+
+                    translate([0,0,ntl-st/2])
+                    cylinder(h=st/2,
+                             r1=od/2, r2=ntr, 
+                             $fn=floor(od*PI/rs), center=false);
+                }
+            }
+            else
+            {
+                cylinder(h=ntl, r=ntd/2, $fn=ntd*PI/rs, center=false);
+            }
+        }
+
+        translate([0,0,ntl+hg]) screw_thread(od,st,lf0,lt,rs,cs);
+    }
+}
+
+module hex_screw_0(od,st,lf0,lt,rs,cs,df,hg,ntl,ntd)
+{
+    ntr=od/2-(st/2)*cos(lf0)/sin(lf0);
+
+    union()
+    {
+        hex_head_0(hg,df);
+
+        translate([0,0,hg])
+        if ( ntl == 0 )
+        {
+            cylinder(h=0.01, r=ntr, center=true);
+        }
+        else
+        {
+            if ( ntd == -1 )
+            {
+                cylinder(h=ntl+0.01, r=ntr, $fn=floor(od*PI/rs), center=false);
+            }
+            else if ( ntd == 0 )
+            {
+                union()
+                {
+                    cylinder(h=ntl-st/2,
+                             r=od/2, $fn=floor(od*PI/rs), center=false);
+
+                    translate([0,0,ntl-st/2])
+                    cylinder(h=st/2,
+                             r1=od/2, r2=ntr, 
+                             $fn=floor(od*PI/rs), center=false);
+                }
+            }
+            else
+            {
+                cylinder(h=ntl, r=ntd/2, $fn=ntd*PI/rs, center=false);
+            }
+        }
+
+        translate([0,0,ntl+hg]) screw_thread(od,st,lf0,lt,rs,cs);
+    }
+}
+
+module thread_shape(cs,lt,or,ir,sn,st)
+{
+    if ( cs == 0 )
+    {
+        cylinder(h=lt, r=or, $fn=sn, center=false);
+    }
+    else
+    {
+        union()
+        {
+            translate([0,0,st/2])
+              cylinder(h=lt-st+0.005, r=or, $fn=sn, center=false);
+
+            if ( cs == -1 || cs == 2 )
+            {
+                cylinder(h=st/2, r1=ir, r2=or, $fn=sn, center=false);
+            }
+            else
+            {
+                cylinder(h=st/2, r=or, $fn=sn, center=false);
+            }
+
+            translate([0,0,lt-st/2])
+            if ( cs == 1 || cs == 2 )
+            {
+                  cylinder(h=st/2, r1=or, r2=ir, $fn=sn, center=false);
+            }
+            else
+            {
+                cylinder(h=st/2, r=or, $fn=sn, center=false);
+            }
+        }
+    }
+}
+
+module full_thread(ttn,st,sn,zt,lfxy,or,ir)
+{
+  if(ir >= 0.2)
+  {
+    for(i=[0:ttn-1])
+    {
+        for(j=[0:sn-1])
+			assign( pt = [	[0,                  0,                  i*st-st            ],
+                        [ir*cos(j*lfxy),     ir*sin(j*lfxy),     i*st+j*zt-st       ],
+                        [ir*cos((j+1)*lfxy), ir*sin((j+1)*lfxy), i*st+(j+1)*zt-st   ],
+								[0,0,i*st],
+                        [or*cos(j*lfxy),     or*sin(j*lfxy),     i*st+j*zt-st/2     ],
+                        [or*cos((j+1)*lfxy), or*sin((j+1)*lfxy), i*st+(j+1)*zt-st/2 ],
+                        [ir*cos(j*lfxy),     ir*sin(j*lfxy),     i*st+j*zt          ],
+                        [ir*cos((j+1)*lfxy), ir*sin((j+1)*lfxy), i*st+(j+1)*zt      ],
+                        [0,                  0,                  i*st+st            ]	])
+        {
+            polyhedron(points=pt,
+              		  triangles=[	[1,0,3],[1,3,6],[6,3,8],[1,6,4],
+											[0,1,2],[1,4,2],[2,4,5],[5,4,6],[5,6,7],[7,6,8],
+											[7,8,3],[0,2,3],[3,2,7],[7,2,5]	]);
+        }
+    }
+  }
+  else
+  {
+    echo("Step Degrees too agresive, the thread will not be made!!");
+    echo("Try to increase de value for the degrees and/or...");
+    echo(" decrease the pitch value and/or...");
+    echo(" increase the outer diameter value.");
+  }
+}
+
+module hex_head(hg,df)
+{
+	rd0=df/2/sin(60);
+	x0=0;	x1=df/2;	x2=x1+hg/2;
+	y0=0;	y1=hg/2;	y2=hg;
+
+	intersection()
+	{
+	   cylinder(h=hg, r=rd0, $fn=6, center=false);
+
+		rotate_extrude(convexity=10, $fn=6*round(df*PI/6/0.5))
+		polygon([ [x0,y0],[x1,y0],[x2,y1],[x1,y2],[x0,y2] ]);
+	}
+}
+
+module hex_head_0(hg,df)
+{
+    cylinder(h=hg, r=df/2/sin(60), $fn=6, center=false);
+}
+
+module hex_countersink_ends(chg,cod,clf,crs,hg)
+{
+    translate([0,0,-0.1])
+    cylinder(h=chg+0.01, 
+             r1=cod/2, 
+             r2=cod/2-(chg+0.1)*cos(clf)/sin(clf),
+             $fn=floor(cod*PI/crs), center=false);
+
+    translate([0,0,hg-chg+0.1])
+    cylinder(h=chg+0.01, 
+             r1=cod/2-(chg+0.1)*cos(clf)/sin(clf),
+             r2=cod/2, 
+             $fn=floor(cod*PI/crs), center=false);
+}
+

chromebook display.scad

@@ -0,0 +1,191 @@
+// Chromebook screen and motherboard assembly
+// length units are millimeters
+
+screenHeight = 157;
+screenHeightAndChin = 167;
+screenChinHeight = screenHeightAndChin - screenHeight;
+
+screenWidth = 267;
+screenChinWidth = 188.5;
+screenWidthWithNoChin = screenWidth - screenChinWidth;
+
+screenTabsDistance = 136; // top of top tab to bottom of bottom tab
+screenTabHeight = 11.49;
+screenTabWidth = 4.96;
+screenTabDistanceToBottom = 16.81; // from bottom-most point of tab
+screenTopTabDistanceToBottom = screenTabsDistance + screenTabDistanceToBottom - screenTabHeight; // from bottom-most point of top tab
+screenTopTabDistanceToTop = screenHeight - screenTabsDistance - screenTabDistanceToBottom; // from top-most point of tab
+
+screenBezel = 4.50;
+screenThickness = 2.60;
+
+batteryWidth = 199;
+batteryHeight = 84;
+batteryThickness = 6;
+batteryTabHeight = 16.40;
+batteryTabWidth = 7.37;
+batteryTabThickness = 1.55 + 0.4;
+batteryTabDistanceToBottom = 25.23;
+
+motherboardLeftHolesDistanceHeight = 95.72;
+motherboardLeftHoleRadius = 2.50 / 2;
+motherboardLeftHolesRealHeightDistance = motherboardLeftHolesDistanceHeight - (2 * motherboardLeftHoleRadius);
+
+motherboardRightHoleDistanceWidth = 211;
+motherboardRightHoleRadius = 3.16 / 2;
+motherboardRightHoleRealWidthDistance = motherboardRightHoleDistanceWidth - motherboardRightHoleRadius;
+motherboardRightHoleDistanceToBottom = 45 - motherboardRightHoleRadius;
+
+motherboardBatteryDistanceHeight = motherboardLeftHolesRealHeightDistance - 20;
+motherboardBatteryDistanceWidth = 31;
+
+screwThreadRadius = 1.90 * 0.49;
+screwSupportRadius = 4.50 / 2;
+
+globalThickness = 2.00;
+
+motherboardElevation = 6.00 + (globalThickness / 3);
+
+include <ng_common/hollow_cylinder.scad>;
+
+module motherboardMount(thickness) {
+    translate([screwSupportRadius, screwSupportRadius, 0])
+    union () {
+        // y-axis support bar
+        translate([-screwSupportRadius,-screwSupportRadius,0]) {
+            //#cube([screwSupportRadius * 2, motherboardLeftHolesRealHeightDistance + (2 * screwSupportRadius), thickness]);
+        }
+        
+        // x-axis support bar
+        translate([-screwSupportRadius, motherboardRightHoleDistanceToBottom -screwSupportRadius, 0]) {
+            //#cube([motherboardRightHoleRealWidthDistance + (2 * screwSupportRadius), screwSupportRadius * 2, thickness]);
+        }
+        translate([0, 0, -motherboardElevation]) {
+            
+            // bottom left hole
+            hollowCylinder(screwThreadRadius, screwSupportRadius, motherboardElevation);
+            
+            // top left hole
+            translate ([0, motherboardLeftHolesRealHeightDistance, 0]) {
+                hollowCylinder(screwThreadRadius, screwSupportRadius, motherboardElevation);
+            }
+            
+            // right hole
+            translate ([motherboardRightHoleRealWidthDistance, motherboardRightHoleDistanceToBottom, 0]) {
+                hollowCylinder(screwThreadRadius, screwSupportRadius, motherboardElevation);
+            }
+        }
+        
+    }
+}
+
+module batteryMount(thickness) {
+    union() {
+        //#cube([batteryWidth + (2 * batteryTabWidth), thickness, thickness]);
+        // left side mount
+        translate([0,0,0]) {
+            cube([batteryTabWidth, batteryTabDistanceToBottom + batteryTabHeight, thickness]);
+            translate([0, 0, -batteryTabThickness]) {
+                cube([batteryTabWidth, batteryTabDistanceToBottom, batteryTabThickness + thickness]);
+                translate([0, 0, -thickness]) {
+                    cube([batteryTabWidth, batteryTabDistanceToBottom + batteryTabHeight, thickness]);
+                }
+            }
+        }
+        // right side mount
+        translate([batteryWidth + batteryTabWidth, 0, 0]) {
+            cube([batteryTabWidth, batteryTabDistanceToBottom + batteryTabHeight, thickness]);
+            translate([0, 0, -batteryTabThickness]) {
+                cube([batteryTabWidth, batteryTabDistanceToBottom, batteryTabThickness + thickness]);
+                translate([0, 0, -thickness]) {
+                    cube([batteryTabWidth, batteryTabDistanceToBottom + batteryTabHeight, thickness]);
+                }
+            }
+        }
+    }
+}
+
+module screenMount(thickness) {
+    // top bar slot
+    translate([screwThreadRadius, -thickness, 0]) {
+        cube([screenWidth / 2, thickness, screenThickness + (2 * thickness)]);
+        translate([0, -screenBezel, 0])
+            cube([screenWidth / 2, screenBezel, thickness]);
+        translate([0, -screenBezel, screenThickness + thickness])
+            cube([screenWidth / 2, screenBezel, thickness]);
+    }
+    
+    // side slot
+    translate([(screenWidth / 2) + screwThreadRadius, -thickness, 0]) {
+        translate([0, -screenTopTabDistanceToTop, 0])
+            cube([thickness, screenTopTabDistanceToTop + thickness, screenThickness + (2 * thickness)]);
+        translate([0, screenTabDistanceToBottom + screenTabHeight - screenHeight])
+            cube([thickness, screenTabsDistance - (2 * screenTabHeight), screenThickness + (2 * thickness)]);
+        translate([0, -screenHeight, 0])
+            cube([thickness, screenTabDistanceToBottom, screenThickness + (2 * thickness)]);
+        translate([-screenBezel, -screenHeight, 0]) {
+            cube([screenBezel + thickness, screenHeight, thickness]);
+            translate([0, 0, thickness + screenThickness])
+                cube([screenBezel + thickness, screenHeight, thickness]);
+        }
+    }
+    
+    // bottom slot
+    translate([(screenWidth / 2) + screwThreadRadius - (screenWidthWithNoChin / 2), -(screenHeight + (thickness * 2)), 0]) {
+        cube([(screenWidthWithNoChin / 2) + thickness, thickness, screenThickness + (2 * thickness)]);
+        cube([(screenWidthWithNoChin / 2) + thickness, screenHeight, thickness]);
+        translate([0, 0, screenThickness + thickness])
+            cube([(screenWidthWithNoChin / 2) + thickness, screenBezel, thickness]);
+    }
+}
+
+module screenMountR(thickness) {
+    hollowCylinder(screwThreadRadius, screwSupportRadius, (screenThickness + (2 * thickness)) / 2);
+    
+    screenMount(thickness);
+    
+    circleSupportRadius = (screenWidth / 6);
+    
+    // backplate cut circle
+    translate([screenWidth * 0.4, -screenHeight * 0.6, 0])
+    difference() {
+        cylinder(r=circleSupportRadius, h = thickness, $fn=360);
+        translate([-0.01, -(circleSupportRadius + 0.01), -0.01])
+            cube([circleSupportRadius + 0.02, (circleSupportRadius * 2) + 0.02, thickness + 0.02]);
+        /*translate([-(circleSupportRadius + 0.01), -0.01, -0.01])
+            cube([circleSupportRadius + 0.02, (screenWidth / 2) + 0.02, thickness + 0.02]);*/
+    }
+}
+
+module screenMountL(thickness) {
+    translate([0, 0, (screenThickness + (2 * thickness)) / 2])
+        hollowCylinder(screwThreadRadius, screwSupportRadius, (screenThickness + (2 * thickness)) / 2);
+    
+    mirror([1, 0, 0])
+        screenMount(thickness);
+    
+    circleSupportRadius = (screenWidth / 3);
+    
+    // backplate cut circle
+    translate([-(screenWidth / 2), 0, 0])
+    difference() {
+        cylinder(r=circleSupportRadius, h = thickness, $fn=360);
+        translate([-circleSupportRadius, -circleSupportRadius, -0.01])
+            cube([circleSupportRadius + 0.02, screenWidth + 0.02, thickness + 0.02]);
+        translate([0, 0, -0.01])
+            cube([circleSupportRadius + 0.02, circleSupportRadius + 0.02, thickness + 0.02]);
+    }
+}
+
+motherboardMount(globalThickness);
+
+translate([motherboardBatteryDistanceWidth, motherboardBatteryDistanceHeight, -(globalThickness / 3)])
+    batteryMount(globalThickness);
+
+/*translate([screwSupportRadius * 2, motherboardRightHoleDistanceToBottom + (screwSupportRadius * 2), 0])
+    #cube([motherboardBatteryDistanceWidth, motherboardLeftHolesRealHeightDistance - motherboardRightHoleDistanceToBottom, globalThickness]);*/
+
+translate([screenWidth / 2 - globalThickness, screenHeight + globalThickness, 0]) {
+    screenMountR(globalThickness);
+    screenMountL(globalThickness);
+}

lawnmower washer.scad

@@ -7,11 +7,14 @@ innerShaftDiameter = 22.30;
 bulbsLength = 32.40;
 bulbsDiameter = 11.60;
 bladeWidth = 44.40 + tolerance;
-washerThickness = 2.00;
-metalWasherThickness = 3.46;
-bladeThickness = 2.24;
+washerThickness = 3.00; // 2.00;
+metalWasherThickness = 4.00; // 3.46;
+bladeThickness = 2.50; // 2.24;
 
-minGuideRidgeThickness = 3.00;
+minGuideRidgeThickness = 8.00; // 3.00;
+
+bladeBumpWidth = bladeWidth * 0.3333;
+bladeBumpHeight = bladeThickness;
 
 innerShaftRadius = innerShaftDiameter / 2;
 bulbRadius = bulbsDiameter / 2;
@@ -19,6 +22,8 @@ washerLength = max(topMetalWasherLength, bladeWidth) + (minGuideRidgeThickness *
 bladeRidgeThickness = max(minGuideRidgeThickness, (washerLength - bladeWidth) / 2);
 metalWasherRidgeThickness = max(minGuideRidgeThickness, (washerLength - topMetalWasherLength) / 2);
 
+bladeBumpOffsetFromCenter = washerLength * 0.375;
+
 circleResolution=360*4; // faces per rotation
 zFightingOffset=0.01; // offset for shape subtraction
 
@@ -32,6 +37,17 @@ module shaft(height) {
         cylinder(r=bulbRadius, h=height, $fn=circleResolution);
 }
 
+module bump(length, width, height) {
+    translate([0, width/2, height])
+        scale([length, width / 2, height])
+            rotate([0, 90, 0])
+                cylinder(r=1, h=1, $fn=circleResolution);
+    translate([0, 0, height])
+        cube([length, width, height + zFightingOffset]);
+}
+
+//bump(washerLength, bladeBumpWidth + zFightingOffset, washerThickness);
+
 difference() {
     translate([-washerLength / 2, -washerLength / 2, 0]) {
         cube([washerLength, washerLength, washerThickness]);
@@ -42,17 +58,33 @@ difference() {
             translate([0, bladeWidth / 2,0])
                 cube([washerLength, bladeRidgeThickness, bladeThickness]);
         }
-        // metal washer ridges
-        translate([washerLength / 2, 0, - washerThickness + zFightingOffset]) {
+        // metal washer ridges (standard)
+        translate([washerLength / 2, 0, - metalWasherThickness + zFightingOffset]) {
             translate([-(topMetalWasherLength / 2) - metalWasherRidgeThickness, 0,0])
                 cube([metalWasherRidgeThickness, washerLength, metalWasherThickness]);
             translate([topMetalWasherLength / 2,0,0])
                 cube([metalWasherRidgeThickness, washerLength, metalWasherThickness]);
         }
+        // metal washer ridges (optional)
+        translate([0, washerLength / 2, - metalWasherThickness + zFightingOffset]) {
+            translate([0, -(topMetalWasherLength / 2) - metalWasherRidgeThickness,0])
+                cube([washerLength, metalWasherRidgeThickness, metalWasherThickness]);
+            translate([0, topMetalWasherLength / 2,0])
+                cube([washerLength, metalWasherRidgeThickness, metalWasherThickness]);
+        }
     }
-    translate([0,0,-zFightingOffset])
+    translate([0,0,-zFightingOffset]) {
+        // shaft
         rotate([0,0,0])
             shaft(washerThickness + (zFightingOffset * 2));
+        // blade shaft bumps
+        translate([0, -bladeBumpWidth/2, washerThickness - bladeBumpHeight]) {
+            translate([-(washerLength + bladeBumpOffsetFromCenter), 0, 0])
+                bump(washerLength, bladeBumpWidth + zFightingOffset, washerThickness);
+            translate([bladeBumpOffsetFromCenter, 0, 0])
+                bump(washerLength, bladeBumpWidth + zFightingOffset, washerThickness);
+        }
+    }
     /*
     // blade stand-in
     translate([-50, -bladeWidth/2, washerThickness])

monitor headphone mount.scad

@@ -18,13 +18,14 @@ screenBaseThickness = 45.00;
 mountProtrusionFromScreenBack = 33.10;
 headphoneArmLength = 50.00;
 
-miscThickness = 6.00;
+horizontalThickness = 8.00;
+verticalThickness = 6.50;
 
 circleResolution=360*4; // faces per rotation
 
 union() {
-    translate([0, 0, mountToScreenBottomHeight + miscThickness]) mountEnd(miscThickness);
-    headphoneMount(miscThickness);
+    translate([0, 0, mountToScreenBottomHeight + horizontalThickness]) mountEnd(verticalThickness);
+    headphoneMount(horizontalThickness, verticalThickness);
     //mountEnd(miscThickness);
 }
 
@@ -49,31 +50,31 @@ module mountEnd(thickness) {
     }
 }
 
-module headphoneMount(thickness) {
+module headphoneMount(zThickness, yThickness) {
     // stock down from monitor mount to clear bottom of monitor
-    cube([mountWidthEnd, thickness, mountToScreenBottomHeight + thickness]);
+    cube([mountWidthEnd, yThickness, mountToScreenBottomHeight + zThickness]);
     //color("red") cube([mountWidthEnd, thickness + screenBaseThickness + mountProtrusionFromScreenBack, thickness]);
     // quarter circle under monitor
     translate ([mountWidthEnd/2, screenBaseThickness + mountProtrusionFromScreenBack, 0]) difference() {
-        cylinder(r = screenBaseThickness + mountProtrusionFromScreenBack, h = thickness, $fn=circleResolution);
+        cylinder(r = screenBaseThickness + mountProtrusionFromScreenBack, h = zThickness, $fn=circleResolution);
         translate([0,0,-0.01])
-            cylinder(r = (screenBaseThickness + mountProtrusionFromScreenBack) - (mountWidthEnd), h = thickness + 0.02, $fn=circleResolution);
-        translate([-(screenBaseThickness + mountProtrusionFromScreenBack) - 0.01, thickness, -0.01])
-            cube([(screenBaseThickness + mountProtrusionFromScreenBack) * 2.01, (screenBaseThickness + mountProtrusionFromScreenBack), thickness + 0.02]);
+            cylinder(r = (screenBaseThickness + mountProtrusionFromScreenBack) - (mountWidthEnd), h = zThickness + 0.02, $fn=circleResolution);
+        translate([-(screenBaseThickness + mountProtrusionFromScreenBack) - 0.01, yThickness, -0.01])
+            cube([(screenBaseThickness + mountProtrusionFromScreenBack) * 2.01, (screenBaseThickness + mountProtrusionFromScreenBack), zThickness + 0.02]);
         translate([mountWidthEnd/2, -(screenBaseThickness + mountProtrusionFromScreenBack)-0.01, -0.01])
-            cube([screenBaseThickness + mountProtrusionFromScreenBack, screenBaseThickness + mountProtrusionFromScreenBack + thickness+0.02, thickness + 0.02]);
+            cube([screenBaseThickness + mountProtrusionFromScreenBack, screenBaseThickness + mountProtrusionFromScreenBack + yThickness+0.02, zThickness + 0.02]);
     }
     // right angle connection reinforcement quarter circle
     difference() {
-        cube([mountWidthEnd, mountWidthEnd + 0.25, mountWidthEnd + thickness]);
-        translate([-0.01, mountWidthEnd + thickness, mountWidthEnd + thickness])
+        cube([mountWidthEnd, mountWidthEnd + 0.25, mountWidthEnd + zThickness]);
+        translate([-0.01, mountWidthEnd + yThickness, mountWidthEnd + zThickness])
             rotate([0,90,0])
                 cylinder(r = mountWidthEnd * 1.02, h = mountWidthEnd + 0.02, $fn=circleResolution);
     }
     // headphone arm
-    translate([-(screenBaseThickness + mountProtrusionFromScreenBack) + (mountWidthEnd / 2), (screenBaseThickness + mountProtrusionFromScreenBack + thickness), 0]) {
-        cube([mountWidthEnd,headphoneArmLength + thickness,thickness]);
-        translate([0, headphoneArmLength + thickness, 0])
-            cube([mountWidthEnd, thickness, thickness * 2]);
+    translate([-(screenBaseThickness + mountProtrusionFromScreenBack) + (mountWidthEnd / 2), (screenBaseThickness + mountProtrusionFromScreenBack + yThickness), 0]) {
+        cube([mountWidthEnd,headphoneArmLength + yThickness,zThickness]);
+        translate([0, headphoneArmLength + yThickness, 0])
+            cube([mountWidthEnd, yThickness / 2, zThickness * 2]);
     }
 }