filamentspool.scad

   1 // -*- C -*-
   2
   3 // filamentspool.scad
   4 // 3D design for filament spools to hold coils as supplied by Faberdashery
   5 //
   6
   7 //
   8 // Copyright 2012,2013,2016 Ian Jackson
   9 //
  10 // This work is free software: you can redistribute it and/or modify
  11 // it under the terms of the GNU General Public License as published by
  12 // the Free Software Foundation, either version 3 of the License, or
  13 // (at your option) any later version.
  14 //
  15 // This work is distributed in the hope that it will be useful,
  16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 // GNU General Public License for more details.
  19 //
  20 // You should have received a copy of the GNU General Public License
  21 // along with this work.  If not, see <http://www.gnu.org/licenses/>
  22 //
  23
  24 //
  25 // Each spool is a hub with 3 or 4 arms.  Each arm has a cup for
  26 // holding the filament.  The effective diameter can be adjusted by
  27 // setting the cup into a different seat in the arm.  The cups are
  28 // held on with simple clips, so the filement coil can easily be
  29 // removed and replaced.
  30 //
  31 // This file (and its includes) can generate:
  32 //
  33 //   - Heavy duty 4-armed spool suitable for holding a 100m
  34 //     Faberdashery coil on the spool arm of a Lulzbot TAZ-5.
  35 //
  36 //     Set
  37 //           fdia=2.85
  38 //           lightduty=false
  39 //     And print following parts
  40 //            Hub
  41 //            ArmEnd x 4
  42 //            FilamentCup x 4  (or FilamentCupPair x 2)
  43 //            CupSecuringClup x 4
  44 //
  45 //     You will also need  4 x M4 machine screws and nuts
  46 //
  47 //   - Light duty 3-armed spool suitable for up to around 30m
  48 //     of Faberdashery 2.85mm PLA.
  49 //
  50 //     Set
  51 //           fdia=2.85
  52 //           lightduty=true
  53 //     And print following parts
  54 //           Hub
  55 //           ArmEnd x 3
  56 //           FilamentCup x 3  (or FilamentCup + FilamentCupPair)
  57 //           CupSecuringClup x 3
  58 //           TowerDoveClipPin x 6
  59 //
  60 //     When assembling, insert one TowerDoveClipPin from each side,
  61 //     joining each ArmEnd to the Hub with two TowerDoveClipPins.
  62 //     Modest force with pliers is good to seat them properly.
  63 //
  64 //     (note that the light duty and heavy duty CupSecuringClips
  65 //      are slightly different)
  66 //
  67 // For the above, I generally used the Cura `Standard' PLA profile.
  68 //
  69 //   - Storage arm suitable for screwing to walls, bookshelves,
  70 //     etc. (requires non-countersunk M4 screws); will hold two
  71 //     heavy duty spools each with a 100m coil.
  72 //
  73 //     Set
  74 //           fdia=2.85
  75 //           lightduty=false
  76 //     And print one of these, according to taste
  77 //            StorageArmLeft
  78 //            StorageArmRight
  79 //
  80 //     NB that the `light duty' version of this is shorter and
  81 //     will only take two `light duty' spools.
  82 //
  83 // For the above, I used the Cura `High detail' PLA profile because
  84 // I wanted it pretty, but the `Standard' profile should do fine.
  85 //
  86 //   - Spool (in many parts) for handing 1.75mm filament, printable
  87 //     on, and with parts for mounting on, a Reprappro Huxley.
  88
  89
  90 fdia=2.85; // or 1.75
  91 lightduty=false; // or true
  92
  93
  94 slop=0.5;
  95 bigslop=slop*2;
  96
  97 function selsz(sm,lt,lg) = fdia < 2 ? sm : lightduty ? lt : lg;
  98 function usedove() = selsz(true,true,false);
  99
 100 num_arms = selsz(3,3,4);
 101
 102 channelslop=selsz(slop,0.75,slop);
 103
 104 exteffrad = 70;
 105 hubeffrad = selsz(30, 82, 40);
 106 hubbigrad = selsz(20, 38, 38);
 107 hublwidth = selsz(3, 2.5, 4);
 108 hubstemwidth = 2;
 109 hublthick = 10;
 110 hubaxlerad = selsz(5, 28/2, 28/2);
 111 totalheightfromtower = 240;
 112 axletowerfudgebend = 0;
 113 axleaxlefudgebend = 3;
 114 axlepadlen = 1.0;
 115
 116 armend_length = 120;
 117
 118 prongthick=selsz(5,4,5);
 119 prongwidth=selsz(5,4,5);
 120 prongribwidth=3;
 121 prongribheight=selsz(0,0,4);
 122 ratchetstep=15;
 123 ratchettooth=3;
 124 ratchettoothheight=5;
 125 ratchettoothsmoothr=1;
 126 ratchettoothslope=0.75;
 127 overlap=0.5;
 128 cupwidth=selsz(40,25,50);
 129 cupheight=selsz(55,25,55);
 130
 131 cupstrong_dx=selsz(0,0,-10);
 132
 133 propxshift = -6;
 134
 135 doveclipheight = 10;
 136
 137 teethh=3;
 138 teethgapx=4+fdia;
 139
 140 prongstalkxwidth=3;
 141
 142 stalklength=selsz(35,25,55);
 143 overclipcupgap=5;
 144 overclipdepth=15;
 145 overcliproundr=2.0;
 146 overclipthick=1.0;
 147 overclipcupnextgap=selsz(20,15,20);
 148
 149 hubaxlelen = selsz(25, 62.5, 77.5);
 150 echo(hubaxlelen);
 151
 152 overclipsmaller=-2.5;
 153 overclipbigger=0.0;
 154
 155 wingspoke=2.5;
 156 wingsize=6;
 157 wingthick=3;
 158
 159 armendwallthick=selsz(2.5, 1.8, 2.5);
 160 armendbasethick=selsz(1.2, 1.2, 1.2);
 161
 162 axlehorizoffset = 12.5;
 163 axlevertheight = 100;
 164 towercliph = 16;
 165 towerclipcount = 3;
 166 towerpillarw = 5;
 167
 168 axlepinrad = 2;
 169 axlepintabrad = 5;
 170
 171 washerthick = 1.2;
 172 washerthinthick = 0.8;
 173 washerverythinthick = 0.4;
 174 washerrad = hubaxlerad + 7.5;
 175 frictionwasherarmwidth = 3;
 176 frictionwasherextrapush = 1.0;
 177
 178 ratchetpawl=ratchetstep-ratchettooth-bigslop*2;
 179
 180 nondove_armhole_x = 32;
 181 nondove_armhole_hole = 4 + 0.8;
 182 nondove_armhole_support = 7;
 183 nondove_armhole_wall = 3.2;
 184 nondove_armhole_slop = 0.5;
 185 nondove_armhole_slop_x = 0.5;
 186
 187 nondove_armbase = nondove_armhole_x + nondove_armhole_hole/2 +
 188   nondove_armhole_support;
 189 echo(nondove_armbase);
 190
 191 include <doveclip.scad>
 192 include <cliphook.scad>
 193 include <filamentteeth.scad>
 194 include <axlepin.scad>
 195
 196 channelwidth = prongthick + channelslop;
 197 channeldepth = prongwidth + ratchettoothheight;
 198 totalwidth = armendwallthick*2 + channelwidth;
 199 totalheight = channeldepth + armendbasethick;
 200 stalkwidth = prongwidth + prongstalkxwidth;
 201
 202 module ArmEnd(length=armend_length){ ////toplevel
 203   if (usedove()) {
 204     translate([ratchettoothsmoothr, channelwidth/2, -armendbasethick]) {
 205       rotate([0,0,-90])
 206         DoveClipPairBase(h=doveclipheight);
 207     }
 208   } else {
 209     difference(){
 210       translate([1, -armendwallthick, -armendbasethick])
 211         mirror([1,0,0])
 212         cube([nondove_armbase+1, totalwidth, totalheight]);
 213       translate([-nondove_armbase + nondove_armhole_x,
 214                  -armendwallthick + totalwidth/2,
 215                  -armendbasethick -1])
 216         cylinder(r= nondove_armhole_hole/2, h=totalheight+2, $fn=10);
 217     }
 218   }
 219
 220   difference(){
 221     translate([0, -armendwallthick, -armendbasethick])
 222       cube([length, totalwidth, totalheight]);
 223     translate([-1, 0, 0])
 224       cube([length+1 - ratchettooth, channelwidth, channeldepth+1]);
 225     translate([-1, 0, ratchettoothheight])
 226       cube([length+2, channelwidth, channeldepth+1]);
 227   }
 228   for (dx = [0 : ratchetstep : length - ratchetstep]) translate([dx,0,0]) {
 229     translate([ratchettoothsmoothr+0.5, armendwallthick/2, 0]) minkowski(){
 230       rotate([90,0,0])
 231         cylinder($fn=20, r=ratchettoothsmoothr, h=armendwallthick);
 232       multmatrix([      [       1, 0, ratchettoothslope, 0      ],
 233                         [       0,      1,      0,      0       ],
 234                         [       0,      0,      1,      0       ],
 235                         [       0,      0,      0,      1       ]])
 236         cube([ratchettooth - ratchettoothsmoothr*2,
 237               channelwidth, ratchettoothheight - ratchettoothsmoothr]);
 238     }
 239   }
 240 }
 241
 242 module FilamentCupHandle(){
 243   pawlusewidth = ratchetpawl-ratchettoothsmoothr*2;
 244   mirror([0,1,0]) {
 245     cube([stalklength, stalkwidth, prongthick]);
 246     translate([stalklength, stalkwidth/2, 0])
 247       cylinder(r=stalkwidth/2, h=prongthick, $fn=20);
 248     translate([ratchettoothsmoothr, stalkwidth, 0]) {
 249       minkowski(){
 250         cylinder($fn=20,r=ratchettoothsmoothr, h=1);
 251         multmatrix([    [       1, -ratchettoothslope, 0, 0     ],
 252                         [       0,      1,      0,      0       ],
 253                         [       0,      0,      1,      0       ],
 254                         [       0,      0,      0,      1       ]])
 255           cube([pawlusewidth,
 256                 ratchettoothheight - ratchettoothsmoothr,
 257                 prongthick - 1]);
 258       }
 259     }
 260   }
 261 }
 262
 263 module FilamentCupCup(){
 264   for (my=[0,1]) mirror([0,my,0]) {
 265     translate([0, cupwidth/2, 0])
 266       cube([cupheight + prongwidth, prongwidth, prongthick]);
 267   }
 268 }
 269
 270 module FilamentCup() { ////toplevel
 271   FilamentCupHandle();
 272
 273   gapy = prongwidth;
 274   dy = cupwidth/2 + gapy + overclipcupgap;
 275   baselen = dy+cupwidth/2;
 276
 277   translate([0, dy, 0])
 278     FilamentCupCup();
 279   cube([prongwidth, baselen+1, prongthick]);
 280
 281   translate([cupstrong_dx, prongwidth, 0]) {
 282     cube([prongwidth, baselen-prongwidth, prongthick]);
 283     for (y = [0, .33, .67, 1])
 284       translate([0, (baselen - prongwidth) * y, 0])
 285         cube([-cupstrong_dx + 1, prongwidth, prongthick]);
 286   }
 287   if (cupstrong_dx != 0) {
 288     rotate([0,0,45])
 289       translate([-prongwidth*.55, -prongwidth*2.1, 0])
 290       cube([prongwidth*(2.65), prongwidth*4.2, prongthick]);
 291   }
 292
 293   translate([0, -0.2, 0])
 294     cube([prongribwidth, baselen, prongthick + prongribheight]);
 295
 296   if (prongribheight > 0) {
 297     translate([-prongwidth, baselen, 0])
 298       cube([cupheight/2, prongwidth + prongribheight, prongribwidth]);
 299   }
 300
 301   midrad = cupwidth/2 + prongwidth/2;
 302
 303   propshift = stalklength - overclipdepth - prongthick + propxshift;
 304   proptaken = propshift;
 305   echo(midrad, propshift, proptaken);
 306
 307   translate([propshift, -1, 0]) {
 308     // something is wrong with the y calculation
 309     cube([prongwidth,
 310           gapy+2,
 311           prongthick]);
 312   }
 313   for (y = [overclipcupgap, overclipcupgap+overclipcupnextgap]) {
 314     translate([cupstrong_dx, y + prongwidth, 0])
 315       rotate([0,0, 102 + fdia])
 316       FilamentTeeth(fdia=fdia, h=teethh);
 317   }
 318   for (x = [-0.3, -1.3]) {
 319     translate([cupheight + overclipcupnextgap*x, baselen + prongwidth, 0])
 320       rotate([0,0, 12 + fdia])
 321       FilamentTeeth(fdia=fdia, h=teethh);
 322   }
 323 }
 324
 325 module CupSecuringClipSolid(w,d,h1,h2){
 326   rotate([0,-90,0]) translate([0,-h1/2,-w/2]) linear_extrude(height=w) {
 327     polygon(points=[[0,0], [d,0], [d,h2], [0,h1]]);
 328   }
 329 }
 330
 331 module CupSecuringClipSolidSmooth(xrad=0, xdepth=0){
 332   hbase = totalheight + prongstalkxwidth - overcliproundr*2;
 333   minkowski(){
 334     CupSecuringClipSolid(w=totalwidth,
 335                          d=overclipdepth + xdepth,
 336                          h1=hbase - overclipsmaller,
 337                          h2=hbase + overclipbigger);
 338     cylinder($fn=20, h=0.01, r=overcliproundr+xrad);
 339   }
 340 }
 341
 342 module CupSecuringClip(){ ////toplevel
 343   wingswidth = wingspoke*2 + overclipthick*2 + overcliproundr*2 + totalwidth;
 344   difference(){
 345     union(){
 346       CupSecuringClipSolidSmooth(xrad=overclipthick, xdepth=0);
 347       translate([-wingswidth/2, -wingsize/2, 0])
 348         cube([wingswidth, wingsize, wingthick]);
 349       translate([-wingsize/2, -wingswidth/2, 0])
 350         cube([wingsize, wingswidth, wingthick]);
 351     }
 352     translate([0,0,-0.1])
 353       CupSecuringClipSolidSmooth(xrad=0, xdepth=0.2);
 354   }
 355 }
 356
 357 module ArmDoveClipPin(){ ////toplevel
 358   DoveClipPin(h=doveclipheight);
 359 }
 360
 361 module TowerDoveClipPin(){ ////toplevel
 362   DoveClipPin(h=towercliph/2);
 363 }
 364
 365 module Hub(){ ////toplevel
 366   axlerad = hubaxlerad + slop;
 367   xmin = axlerad+hublwidth/2;
 368   xmax = hubbigrad-hublwidth/2;
 369   hole = hubeffrad - hubbigrad - DoveClip_depth() - hublwidth*2;
 370   holewidth = DoveClipPairSane_width() - hubstemwidth*2;
 371   nondove_allwidth = nondove_armhole_wall*2 + totalwidth;
 372   difference(){
 373     union(){
 374       difference(){
 375         cylinder($fn=60, h=hublthick, r=hubbigrad);
 376         translate([0,0,-1])
 377           cylinder($fn=30, h=hublthick+2, r=(hubbigrad-hublwidth));
 378       }
 379       cylinder(h=hubaxlelen, r=axlerad+hublwidth);
 380       for (ang=[0 : 360/num_arms : 359])
 381         rotate([0,0,ang]) {
 382           if (usedove()){
 383             difference() {
 384               translate([hubeffrad,0,0])
 385                 DoveClipPairSane(h=doveclipheight,
 386                                  baseextend = (hubeffrad - DoveClip_depth()
 387                                                - hubbigrad + hublwidth));
 388               if (hole>hublwidth && holewidth > 2) {
 389                 translate([hubbigrad + hublwidth, -holewidth/2, -1])
 390                   cube([hole, holewidth, hublthick+2]);
 391               }
 392             }
 393           } else {
 394             difference(){
 395               translate([0,
 396                          -nondove_allwidth/2,
 397                          0])
 398                 cube([hubeffrad + nondove_armhole_x
 399                       + nondove_armhole_hole/2 + nondove_armhole_support,
 400                       nondove_allwidth,
 401                       nondove_armhole_wall + totalheight]);
 402               translate([hubeffrad - nondove_armhole_slop_x,
 403                          -nondove_allwidth/2
 404                          + nondove_armhole_wall - nondove_armhole_slop,
 405                          nondove_armhole_wall])
 406                 cube([nondove_armhole_x + 50,
 407                       totalwidth + nondove_armhole_slop*2,
 408                       totalheight + 1]);
 409               translate([hubeffrad + nondove_armhole_x, 0, -20])
 410                 cylinder(r= nondove_armhole_hole/2, h=50, $fn=10);
 411             }
 412           }
 413         }
 414       for (ang = [0 : 180/num_arms : 359])
 415         rotate([0,0,ang]) rotate([90,0,0]) {
 416           translate([0,0,-hublwidth/2])
 417             linear_extrude(height=hublwidth)
 418             polygon([[xmin,0.05], [xmax,0.05],
 419                      [xmax,hublthick-0.2], [xmin, hubaxlelen-0.2]]);
 420         }
 421     }
 422     translate([0,0,-1]) cylinder($fn=60, h=hubaxlelen+2, r=axlerad);
 423   }
 424 }
 425
 426 module ArmExtender(){ ////toplevel
 427   DoveClipExtender(length=exteffrad-hubeffrad,
 428                    ha=doveclipheight,
 429                    hb=doveclipheight);
 430 }
 431
 432 module FsAxlePin(){ ////toplevel
 433   AxlePin(hubaxlerad, washerrad*2, axlepinrad, axlepintabrad, slop);
 434 }
 435
 436 module Axle(){ ////toplevel
 437   pillarswidth = DoveClipPairSane_width(towerclipcount);
 438
 439   rotate([0,0, -( axleaxlefudgebend + atan(slop/hubaxlelen) ) ])
 440   translate([-axlehorizoffset, -axlevertheight, 0]) {
 441     rotate([0,0,-axletowerfudgebend])
 442     rotate([0,0,-90])
 443       DoveClipPairSane(h=towercliph, count=towerclipcount, baseextend=3);
 444     translate([0, DoveClip_depth(), 0])
 445     rotate([0,0,90])
 446       ExtenderPillars(axlevertheight - DoveClip_depth(),
 447                       pillarswidth, towercliph,
 448                       pillarw=towerpillarw);
 449   }
 450
 451   axleclearlen = hubaxlelen + slop*4 + washerthick*2 + axlepadlen;
 452   axlerad = hubaxlerad-slop;
 453   bump = axlerad * 0.2;
 454   shift = axlerad-bump;
 455   joinbelowallow = 3;
 456
 457   intersection(){
 458     translate([0, 0, shift]) {
 459       difference() {
 460         union(){
 461           translate([-1, 0, 0])
 462             rotate([0,90,0])
 463             cylinder($fn=60,
 464                      r = axlerad,
 465                      h = 1 + axleclearlen + axlepinrad*2 + 2);
 466           mirror([1,0,0]) rotate([0,90,0])
 467             cylinder(r = axlerad*1.75, h = 3);
 468           intersection(){
 469             mirror([1,0,0])
 470               translate([axlehorizoffset - pillarswidth/2, 0, 0])
 471               rotate([0,90,0])
 472               cylinder($fn=60,
 473                        r = towercliph - shift,
 474                        h = pillarswidth);
 475             translate([-50, -joinbelowallow, -50])
 476               cube([100, joinbelowallow+50, 100]);
 477           }
 478         }
 479         rotate([90,0,0])
 480         translate([axleclearlen + axlepinrad/2, 0, -25])
 481           cylinder(r = axlepinrad + slop, h=50);
 482       }
 483     }
 484     translate([-50,-50,0]) cube([100,100,100]);
 485   }
 486 }
 487
 488 module washer(thick){
 489   Washer(hubaxlerad, washerrad, thick, slop);
 490 }
 491
 492 module AxleWasher(){ ////toplevel
 493   washer(thick=washerthick);
 494 }
 495
 496 module AxleThinWasher(){ ////toplevel
 497   washer(thick=washerthinthick);
 498 }
 499
 500 module AxleVeryThinWasher(){ ////toplevel
 501   washer(thick=washerverythinthick);
 502 }
 503
 504 module AxleFrictionWasher(){ ////toplevel
 505   difference(){
 506     cylinder(h=washerthick, r=washerrad);
 507     translate([0,0,-1]) cylinder(h=washerthick+2, r=hubaxlerad+slop);
 508   }
 509   frarmr = hubbigrad;
 510   frarmw = frictionwasherarmwidth;
 511   frarmpawlr = hublwidth;
 512   frarmpawlpush = slop*4 + frictionwasherextrapush;
 513   for (ang=[0,180]) rotate([0,0,ang]) {
 514     translate([washerrad-1, -frarmw/2, 0])
 515       cube([frarmr - washerrad + 1, frarmw, washerthick]);
 516     intersection(){
 517       translate([frarmr - frarmpawlr, -50, 0])
 518         cube([frarmpawlr, 100, 50]);
 519       rotate([0,90,0])
 520         cylinder(h = 50, r = frarmpawlpush, $fn=36);
 521     }
 522   }
 523 }
 524
 525 module TowerExtender(){ ////toplevel
 526   l = totalheightfromtower - axlevertheight;
 527   echo("TowerExtender",l);
 528   DoveClipExtender(length = l,
 529                    ha = towercliph, hb = towercliph,
 530                    counta = towerclipcount, countb = towerclipcount,
 531                    pillarw = towerpillarw);
 532 }
 533
 534 module FilamentCupPair(){ ////toplevel
 535   FilamentCup();
 536   translate([cupheight + prongthick*3,
 537              cupwidth/2*1.7,
 538              0])
 539     rotate([0,0,180]) FilamentCup();
 540 }
 541
 542 //----- storarm -----
 543
 544 storarm_hooklen = 8;
 545 storarm_hookheight = 5;
 546 storarm_thick = 10;
 547 storarm_axleslop = 4;
 548
 549 storarm_base_w = 30;
 550 storarm_base_h = 100;
 551 storarm_base_d = 15;
 552 storarm_base_mind = 2;
 553
 554 storarm_cope_hubaxle_mk1 = true;
 555
 556 storarm_screw_hole = 4;
 557 storarm_screw_hole_slop = 0.5;
 558 storarm_besides_hole = 4;
 559
 560 storarm_under_hole = 5;
 561 storarm_screw_hole_head = 8.8;
 562 storarm_screw_hole_head_slop = 1.5;
 563
 564 // calculated
 565
 566 storarm_axlerad = hubaxlerad - storarm_axleslop;
 567 storarm_mainlen = hubaxlelen*2 + storarm_axleslop
 568   + (storarm_cope_hubaxle_mk1 ? 10 : 0);
 569 storarm_totlen = storarm_mainlen + storarm_hooklen;
 570
 571 storarm_mid_off_y = storarm_axlerad;
 572
 573 storarm_base_off_y = storarm_mid_off_y + storarm_base_h/2;
 574
 575 module StorageArmDiagPartSide(xmin, xmax){
 576   xsz = xmax-xmin;
 577   yuse = storarm_thick/2;
 578
 579   intersection(){
 580     translate([xmin-1, -storarm_axlerad, storarm_thick/2])
 581       rotate([0,90,0])
 582       cylinder(r=storarm_axlerad, h=xsz+2, $fn=60);
 583     translate([xmin, -yuse, 0])
 584       cube([xsz, yuse, storarm_thick]);
 585   }
 586 }
 587
 588 module StorageArmDiagPart(xmin, xmax, shear, adjbot){
 589   hull(){
 590     StorageArmDiagPartSide(xmin,xmax);
 591
 592     multmatrix([[1,0,0,0],
 593                 [shear,1,0,0],
 594                 [0,0,1,0],
 595                 [0,0,0,1]])
 596       translate([0, -storarm_axlerad*2 + adjbot, 0])
 597       mirror([0,1,0])
 598       StorageArmDiagPartSide(xmin,xmax);
 599   }
 600 }
 601
 602 module StorageArmBaseTemplate(){
 603   square([storarm_base_w, storarm_base_h]);
 604 }
 605
 606 module StorageArmAtMountingHoles(){
 607   bes = storarm_besides_hole + storarm_screw_hole;
 608
 609   x0 = bes;
 610   x1 = storarm_base_w-bes;
 611   y1 = storarm_base_h - bes;
 612   y0 = bes;
 613
 614   for (pos=[ [x0, y1],
 615              [x1, y1],
 616              [x1, y0] ]) {
 617     rotate([0,90,0])
 618       translate([pos[0] - storarm_base_w,
 619                  pos[1] - storarm_base_off_y, -storarm_base_d])
 620       children();
 621   }
 622 }
 623
 624 module StorageArmRight(){ ////toplevel
 625   shear = storarm_hookheight / (storarm_mainlen/2);
 626
 627   StorageArmDiagPart(-1, storarm_mainlen/2+1, shear, 0);
 628   StorageArmDiagPart(storarm_mainlen/2-1, storarm_mainlen+1, shear/2,
 629                      storarm_hookheight/2);
 630
 631   translate([0, storarm_hookheight, 0])
 632     StorageArmDiagPart(storarm_mainlen, storarm_totlen,
 633                        shear/2, -storarm_hookheight/2);
 634
 635   difference(){
 636     union(){
 637       hull(){
 638         translate([-storarm_base_d, -storarm_base_off_y, storarm_base_w])
 639           rotate([0,90,0])
 640           linear_extrude(height=storarm_base_mind)
 641           StorageArmBaseTemplate();
 642         StorageArmDiagPart(-1, 0, shear, 0);
 643       }
 644       StorageArmAtMountingHoles(){
 645         cylinder(r= storarm_screw_hole_head/2,
 646                  h=10);
 647       }
 648     }
 649     StorageArmAtMountingHoles(){
 650       translate([0,0,-1])
 651         cylinder(r= (storarm_screw_hole + storarm_screw_hole_slop)/2 ,
 652                  h=20);
 653       translate([0,0,storarm_under_hole])
 654         cylinder(r= (storarm_screw_hole_head + storarm_screw_hole_head_slop)/2,
 655                  h=20);
 656     }
 657   }
 658 }
 659
 660 module StorageArmLeft(){ ////toplevel
 661   mirror([1,0,0]) StorageArmRight();
 662 }
 663
 664 module StorArmHoleTest(){ ////toplevel
 665   sz = storarm_screw_hole_head + storarm_besides_hole*2;
 666   intersection(){
 667     StorageArmRight();
 668     translate([-50, -storarm_base_off_y, -1])
 669       cube([100, sz, sz+1]);
 670   }
 671 }
 672
 673
 674 module Demo(){
 675   translate([-hubeffrad-30,50,0]) Hub();
 676   ArmEnd();
 677   translate([0,50,0]) FilamentCup();
 678 }
 679
 680 //ArmEnd();
 681 //FilamentCup();
 682 //FilamentCupPair();
 683 //CupSecuringClip();
 684 //Hub();
 685 //ArmExtender();
 686 //Axle();
 687 //AxleWasher();
 688 //AxlePin();
 689 //AxleFrictionWasher();
 690 //StorageArmLeft();
 691 //StorArmHoleTest();
 692 //Demo();