chiark / gitweb /
filamentspool: FilamentGuideArm: Provide FilamentGuideArmPrint, as printed (v1)
[reprap-play.git] / 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 //            CupSecuringClip 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 //           CupSecuringClip 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 // When mounting either spool on the TAZ-5 spool arm, put the `pointy'
68 // end of the hub towards the printer - ie, put put the spool on
69 // `backwards'.  This ensures that the spool's arms will clear the
70 // printer framework.
71 //
72 // For the above, I generally used the Cura `Standard' PLA profile.
73 //
74 //   - Storage arm suitable for screwing to walls, bookshelves,
75 //     etc. (requires non-countersunk M4 screws); will hold two
76 //     heavy duty spools each with a 100m coil.
77 //
78 //     Set
79 //           fdia=2.85
80 //           lightduty=false
81 //     And print one of these, according to taste
82 //            StorageArmLeft
83 //            StorageArmRight
84 //
85 //     NB that the `light duty' version of this is shorter and
86 //     will only take two `light duty' spools.
87 //
88 // For the above, I used the Cura `High detail' PLA profile because
89 // I wanted it pretty, but the `Standard' profile should do fine.
90 //
91 //   - Spool (in many parts) for handing 1.75mm filament, printable
92 //     on, and with parts for mounting on, a Reprappro Huxley.
93
94
95 fdia=2.85; // or 1.75
96 lightduty=false; // or true
97
98
99 slop=0.5;
100 bigslop=slop*2;
101
102 function selsz(sm,lt,lg) = fdia < 2 ? sm : lightduty ? lt : lg;
103 function usedove() = selsz(true,true,false);
104
105 num_arms = selsz(3,3,4);
106
107 channelslop=selsz(slop,0.75,slop);
108
109 exteffrad = 70;
110 hubeffrad = selsz(30, 82, 40);
111 hubbigrad = selsz(20, 38, 38);
112 hublwidth = selsz(3, 2.5, 4);
113 hubstemwidth = 2;
114 hublthick = 10;
115 hubaxlerad = selsz(5, 28/2, 28/2);
116 totalheightfromtower = 240;
117 axletowerfudgebend = 0;
118 axleaxlefudgebend = 3;
119 axlepadlen = 1.0;
120
121 armend_length = 120;
122
123 prongthick=selsz(5,4,5);
124 prongwidth=selsz(5,4,5);
125 prongribwidth=3;
126 prongribheight=selsz(0,0,4);
127 ratchetstep=15;
128 ratchettooth=3;
129 ratchettoothheight=5;
130 ratchettoothsmoothr=1;
131 ratchettoothslope=0.75;
132 overlap=0.5;
133 cupwidth=selsz(40,25,50);
134 cupheight=selsz(55,25,55);
135
136 cupstrong_dx=selsz(0,0,-10);
137
138 propxshift = -6;
139
140 doveclipheight = 10;
141
142 teethh=3;
143 teethgapx=4+fdia;
144
145 prongstalkxwidth=3;
146
147 stalklength=selsz(35,25,55);
148 overclipcupgap=5;
149 overclipdepth=15;
150 overcliproundr=2.0;
151 overclipthick=1.0;
152 overclipcupnextgap=selsz(20,15,20);
153
154 hubaxlelen = selsz(25, 62.5, 77.5);
155 echo(hubaxlelen);
156
157 overclipsmaller=-2.5;
158 overclipbigger=0.0;
159
160 wingspoke=2.5;
161 wingsize=6;
162 wingthick=3;
163
164 armendwallthick=selsz(2.5, 1.8, 2.5);
165 armendbasethick=selsz(1.2, 1.2, 1.2);
166
167 axlehorizoffset = 12.5;
168 axlevertheight = 100;
169 towercliph = 16;
170 towerclipcount = 3;
171 towerpillarw = 5;
172
173 axlepinrad = 2;
174 axlepintabrad = 5;
175
176 washerthick = 1.2;
177 washerthinthick = 0.8;
178 washerverythinthick = 0.4;
179 washerrad = hubaxlerad + 7.5;
180 frictionwasherarmwidth = 3;
181 frictionwasherextrapush = 1.0;
182
183 ratchetpawl=ratchetstep-ratchettooth-bigslop*2;
184
185 nondove_armhole_x = 32;
186 nondove_armhole_hole = 4 + 0.8;
187 nondove_armhole_support = 7;
188 nondove_armhole_wall = 3.2;
189 nondove_armhole_slop = 0.5;
190 nondove_armhole_slop_x = 0.5;
191
192 nondove_armbase = nondove_armhole_x + nondove_armhole_hole/2 +
193   nondove_armhole_support;
194 echo(nondove_armbase);
195
196 include <doveclip.scad>
197 include <cliphook.scad>
198 include <filamentteeth.scad>
199 include <axlepin.scad>
200
201 channelwidth = prongthick + channelslop;
202 channeldepth = prongwidth + ratchettoothheight;
203 totalwidth = armendwallthick*2 + channelwidth;
204 totalheight = channeldepth + armendbasethick;
205 stalkwidth = prongwidth + prongstalkxwidth;
206
207 module ArmEnd(length=armend_length){ ////toplevel
208   if (usedove()) {
209     translate([ratchettoothsmoothr, channelwidth/2, -armendbasethick]) {
210       rotate([0,0,-90])
211         DoveClipPairBase(h=doveclipheight);
212     }
213   } else {
214     difference(){
215       translate([1, -armendwallthick, -armendbasethick])
216         mirror([1,0,0])
217         cube([nondove_armbase+1, totalwidth, totalheight]);
218       translate([-nondove_armbase + nondove_armhole_x,
219                  -armendwallthick + totalwidth/2,
220                  -armendbasethick -1])
221         cylinder(r= nondove_armhole_hole/2, h=totalheight+2, $fn=10);
222     }
223   }
224
225   difference(){
226     translate([0, -armendwallthick, -armendbasethick])
227       cube([length, totalwidth, totalheight]);
228     translate([-1, 0, 0])
229       cube([length+1 - ratchettooth, channelwidth, channeldepth+1]);
230     translate([-1, 0, ratchettoothheight])
231       cube([length+2, channelwidth, channeldepth+1]);
232   }
233   for (dx = [0 : ratchetstep : length - ratchetstep]) translate([dx,0,0]) {
234     translate([ratchettoothsmoothr+0.5, armendwallthick/2, 0]) minkowski(){
235       rotate([90,0,0])
236         cylinder($fn=20, r=ratchettoothsmoothr, h=armendwallthick);
237       multmatrix([      [       1, 0, ratchettoothslope, 0      ],
238                         [       0,      1,      0,      0       ],
239                         [       0,      0,      1,      0       ],
240                         [       0,      0,      0,      1       ]])
241         cube([ratchettooth - ratchettoothsmoothr*2,
242               channelwidth, ratchettoothheight - ratchettoothsmoothr]);
243     }
244   }
245 }
246
247 module FilamentCupHandle(){
248   pawlusewidth = ratchetpawl-ratchettoothsmoothr*2;
249   mirror([0,1,0]) {
250     cube([stalklength, stalkwidth, prongthick]);
251     translate([stalklength, stalkwidth/2, 0])
252       cylinder(r=stalkwidth/2, h=prongthick, $fn=20);
253     translate([ratchettoothsmoothr, stalkwidth, 0]) {
254       minkowski(){
255         cylinder($fn=20,r=ratchettoothsmoothr, h=1);
256         multmatrix([    [       1, -ratchettoothslope, 0, 0     ],
257                         [       0,      1,      0,      0       ],
258                         [       0,      0,      1,      0       ],
259                         [       0,      0,      0,      1       ]])
260           cube([pawlusewidth,
261                 ratchettoothheight - ratchettoothsmoothr,
262                 prongthick - 1]);
263       }
264     }
265   }
266 }
267
268 module FilamentCupCup(){
269   for (my=[0,1]) mirror([0,my,0]) {
270     translate([0, cupwidth/2, 0])
271       cube([cupheight + prongwidth, prongwidth, prongthick]);
272   }
273 }
274
275 module FilamentCup() { ////toplevel
276   FilamentCupHandle();
277
278   gapy = prongwidth;
279   dy = cupwidth/2 + gapy + overclipcupgap;
280   baselen = dy+cupwidth/2;
281
282   translate([0, dy, 0])
283     FilamentCupCup();
284   cube([prongwidth, baselen+1, prongthick]);
285
286   translate([cupstrong_dx, prongwidth, 0]) {
287     cube([prongwidth, baselen-prongwidth, prongthick]);
288     for (y = [0, .33, .67, 1])
289       translate([0, (baselen - prongwidth) * y, 0])
290         cube([-cupstrong_dx + 1, prongwidth, prongthick]);
291   }
292   if (cupstrong_dx != 0) {
293     rotate([0,0,45])
294       translate([-prongwidth*.55, -prongwidth*2.1, 0])
295       cube([prongwidth*(2.65), prongwidth*4.2, prongthick]);
296   }
297
298   translate([0, -0.2, 0])
299     cube([prongribwidth, baselen, prongthick + prongribheight]);
300
301   if (prongribheight > 0) {
302     translate([-prongwidth, baselen, 0])
303       cube([cupheight/2, prongwidth + prongribheight, prongribwidth]);
304   }
305
306   midrad = cupwidth/2 + prongwidth/2;
307
308   propshift = stalklength - overclipdepth - prongthick + propxshift;
309   proptaken = propshift;
310   echo(midrad, propshift, proptaken);
311
312   translate([propshift, -1, 0]) {
313     // something is wrong with the y calculation
314     cube([prongwidth,
315           gapy+2,
316           prongthick]);
317   }
318   for (y = [overclipcupgap, overclipcupgap+overclipcupnextgap]) {
319     translate([cupstrong_dx, y + prongwidth, 0])
320       rotate([0,0, 102 + fdia])
321       FilamentTeeth(fdia=fdia, h=teethh);
322   }
323   for (x = [-0.3, -1.3]) {
324     translate([cupheight + overclipcupnextgap*x, baselen + prongwidth, 0])
325       rotate([0,0, 12 + fdia])
326       FilamentTeeth(fdia=fdia, h=teethh);
327   }      
328 }
329
330 module CupSecuringClipSolid(w,d,h1,h2){
331   rotate([0,-90,0]) translate([0,-h1/2,-w/2]) linear_extrude(height=w) {
332     polygon(points=[[0,0], [d,0], [d,h2], [0,h1]]);
333   }
334 }
335
336 module CupSecuringClipSolidSmooth(xrad=0, xdepth=0){
337   hbase = totalheight + prongstalkxwidth - overcliproundr*2;
338   minkowski(){
339     CupSecuringClipSolid(w=totalwidth,
340                          d=overclipdepth + xdepth,
341                          h1=hbase - overclipsmaller,
342                          h2=hbase + overclipbigger);
343     cylinder($fn=20, h=0.01, r=overcliproundr+xrad);
344   }
345 }
346
347 module CupSecuringClip(){ ////toplevel
348   wingswidth = wingspoke*2 + overclipthick*2 + overcliproundr*2 + totalwidth;
349   difference(){
350     union(){
351       CupSecuringClipSolidSmooth(xrad=overclipthick, xdepth=0);
352       translate([-wingswidth/2, -wingsize/2, 0])
353         cube([wingswidth, wingsize, wingthick]);
354       translate([-wingsize/2, -wingswidth/2, 0])
355         cube([wingsize, wingswidth, wingthick]);
356     }
357     translate([0,0,-0.1])
358       CupSecuringClipSolidSmooth(xrad=0, xdepth=0.2);
359   }
360 }
361
362 module ArmDoveClipPin(){ ////toplevel
363   DoveClipPin(h=doveclipheight);
364 }
365
366 module TowerDoveClipPin(){ ////toplevel
367   DoveClipPin(h=towercliph/2);
368 }
369
370 module Hub(){ ////toplevel
371   axlerad = hubaxlerad + slop;
372   xmin = axlerad+hublwidth/2;
373   xmax = hubbigrad-hublwidth/2;
374   hole = hubeffrad - hubbigrad - DoveClip_depth() - hublwidth*2;
375   holewidth = DoveClipPairSane_width() - hubstemwidth*2;
376   nondove_allwidth = nondove_armhole_wall*2 + totalwidth;
377   difference(){
378     union(){
379       difference(){
380         cylinder($fn=60, h=hublthick, r=hubbigrad);
381         translate([0,0,-1])
382           cylinder($fn=30, h=hublthick+2, r=(hubbigrad-hublwidth));
383       }
384       cylinder(h=hubaxlelen, r=axlerad+hublwidth);
385       for (ang=[0 : 360/num_arms : 359])
386         rotate([0,0,ang]) {
387           if (usedove()){
388             difference() {
389               translate([hubeffrad,0,0])
390                 DoveClipPairSane(h=doveclipheight,
391                                  baseextend = (hubeffrad - DoveClip_depth()
392                                                - hubbigrad + hublwidth));
393               if (hole>hublwidth && holewidth > 2) {
394                 translate([hubbigrad + hublwidth, -holewidth/2, -1])
395                   cube([hole, holewidth, hublthick+2]);
396               }
397             }
398           } else {
399             difference(){
400               translate([0,
401                          -nondove_allwidth/2,
402                          0])
403                 cube([hubeffrad + nondove_armhole_x
404                       + nondove_armhole_hole/2 + nondove_armhole_support,
405                       nondove_allwidth,
406                       nondove_armhole_wall + totalheight]);
407               translate([hubeffrad - nondove_armhole_slop_x,
408                          -nondove_allwidth/2
409                          + nondove_armhole_wall - nondove_armhole_slop,
410                          nondove_armhole_wall])
411                 cube([nondove_armhole_x + 50,
412                       totalwidth + nondove_armhole_slop*2,
413                       totalheight + 1]);
414               translate([hubeffrad + nondove_armhole_x, 0, -20])
415                 cylinder(r= nondove_armhole_hole/2, h=50, $fn=10);
416             }
417           }
418         }
419       for (ang = [0 : 180/num_arms : 359])
420         rotate([0,0,ang]) rotate([90,0,0]) {
421           translate([0,0,-hublwidth/2])
422             linear_extrude(height=hublwidth)
423             polygon([[xmin,0.05], [xmax,0.05],
424                      [xmax,hublthick-0.2], [xmin, hubaxlelen-0.2]]);
425         }
426     }
427     translate([0,0,-1]) cylinder($fn=60, h=hubaxlelen+2, r=axlerad);
428   }
429 }
430
431 module ArmExtender(){ ////toplevel
432   DoveClipExtender(length=exteffrad-hubeffrad,
433                    ha=doveclipheight,
434                    hb=doveclipheight);
435 }
436
437 module FsAxlePin(){ ////toplevel
438   AxlePin(hubaxlerad, washerrad*2, axlepinrad, axlepintabrad, slop);
439 }
440
441 module Axle(){ ////toplevel
442   pillarswidth = DoveClipPairSane_width(towerclipcount);
443
444   rotate([0,0, -( axleaxlefudgebend + atan(slop/hubaxlelen) ) ])
445   translate([-axlehorizoffset, -axlevertheight, 0]) {
446     rotate([0,0,-axletowerfudgebend])
447     rotate([0,0,-90])
448       DoveClipPairSane(h=towercliph, count=towerclipcount, baseextend=3);
449     translate([0, DoveClip_depth(), 0])
450     rotate([0,0,90])
451       ExtenderPillars(axlevertheight - DoveClip_depth(),
452                       pillarswidth, towercliph,
453                       pillarw=towerpillarw);
454   }
455
456   axleclearlen = hubaxlelen + slop*4 + washerthick*2 + axlepadlen;
457   axlerad = hubaxlerad-slop;
458   bump = axlerad * 0.2;
459   shift = axlerad-bump;
460   joinbelowallow = 3;
461
462   intersection(){
463     translate([0, 0, shift]) {
464       difference() {
465         union(){
466           translate([-1, 0, 0])
467             rotate([0,90,0])
468             cylinder($fn=60,
469                      r = axlerad,
470                      h = 1 + axleclearlen + axlepinrad*2 + 2);
471           mirror([1,0,0]) rotate([0,90,0])
472             cylinder(r = axlerad*1.75, h = 3);
473           intersection(){
474             mirror([1,0,0])
475               translate([axlehorizoffset - pillarswidth/2, 0, 0])
476               rotate([0,90,0])
477               cylinder($fn=60,
478                        r = towercliph - shift,
479                        h = pillarswidth);
480             translate([-50, -joinbelowallow, -50])
481               cube([100, joinbelowallow+50, 100]);
482           }
483         }
484         rotate([90,0,0])
485         translate([axleclearlen + axlepinrad/2, 0, -25])
486           cylinder(r = axlepinrad + slop, h=50);
487       }
488     }
489     translate([-50,-50,0]) cube([100,100,100]);
490   }
491 }
492
493 module washer(thick){
494   Washer(hubaxlerad, washerrad, thick, slop);
495 }
496
497 module AxleWasher(){ ////toplevel
498   washer(thick=washerthick);
499 }
500
501 module AxleThinWasher(){ ////toplevel
502   washer(thick=washerthinthick);
503 }
504
505 module AxleVeryThinWasher(){ ////toplevel
506   washer(thick=washerverythinthick);
507 }
508
509 module AxleFrictionWasher(){ ////toplevel
510   difference(){
511     cylinder(h=washerthick, r=washerrad);
512     translate([0,0,-1]) cylinder(h=washerthick+2, r=hubaxlerad+slop);
513   }
514   frarmr = hubbigrad;
515   frarmw = frictionwasherarmwidth;
516   frarmpawlr = hublwidth;
517   frarmpawlpush = slop*4 + frictionwasherextrapush;
518   for (ang=[0,180]) rotate([0,0,ang]) {
519     translate([washerrad-1, -frarmw/2, 0])
520       cube([frarmr - washerrad + 1, frarmw, washerthick]);
521     intersection(){
522       translate([frarmr - frarmpawlr, -50, 0])
523         cube([frarmpawlr, 100, 50]);
524       rotate([0,90,0])
525         cylinder(h = 50, r = frarmpawlpush, $fn=36);
526     }
527   }
528 }
529
530 module TowerExtender(){ ////toplevel
531   l = totalheightfromtower - axlevertheight;
532   echo("TowerExtender",l);
533   DoveClipExtender(length = l,
534                    ha = towercliph, hb = towercliph,
535                    counta = towerclipcount, countb = towerclipcount,
536                    pillarw = towerpillarw);
537 }
538
539 module FilamentCupPair(){ ////toplevel
540   FilamentCup();
541   translate([cupheight + prongthick*3,
542              cupwidth/2*1.7,
543              0])
544     rotate([0,0,180]) FilamentCup();
545 }
546
547 //----- storarm -----
548
549 storarm_hooklen = 8;
550 storarm_hookheight = 5;
551 storarm_thick = 10;
552 storarm_axleslop = 4;
553
554 storarm_base_w = 30;
555 storarm_base_h = 100;
556 storarm_base_d = 15;
557 storarm_base_mind = 2;
558
559 storarm_cope_hubaxle_mk1 = true;
560
561 storarm_screw_hole = 4;
562 storarm_screw_hole_slop = 0.5;
563 storarm_besides_hole = 4;
564
565 storarm_under_hole = 5;
566 storarm_screw_hole_head = 8.8;
567 storarm_screw_hole_head_slop = 1.5;
568
569 // calculated
570
571 storarm_axlerad = hubaxlerad - storarm_axleslop;
572 storarm_mainlen = hubaxlelen*2 + storarm_axleslop
573   + (storarm_cope_hubaxle_mk1 ? 10 : 0);
574 storarm_totlen = storarm_mainlen + storarm_hooklen;
575
576 storarm_mid_off_y = storarm_axlerad;
577
578 storarm_base_off_y = storarm_mid_off_y + storarm_base_h/2;
579
580 module StorageArmDiagPartSide(xmin, xmax){
581   xsz = xmax-xmin;
582   yuse = storarm_thick/2;
583
584   intersection(){
585     translate([xmin-1, -storarm_axlerad, storarm_thick/2])
586       rotate([0,90,0])
587       cylinder(r=storarm_axlerad, h=xsz+2, $fn=60);
588     translate([xmin, -yuse, 0])
589       cube([xsz, yuse, storarm_thick]);
590   }
591 }
592
593 module StorageArmDiagPart(xmin, xmax, shear, adjbot){
594   hull(){
595     StorageArmDiagPartSide(xmin,xmax);
596
597     multmatrix([[1,0,0,0],
598                 [shear,1,0,0],
599                 [0,0,1,0],
600                 [0,0,0,1]])
601       translate([0, -storarm_axlerad*2 + adjbot, 0])
602       mirror([0,1,0])
603       StorageArmDiagPartSide(xmin,xmax);
604   }
605 }
606
607 module StorageArmBaseTemplate(){
608   square([storarm_base_w, storarm_base_h]);
609 }
610
611 module StorageArmAtMountingHoles(){
612   bes = storarm_besides_hole + storarm_screw_hole;
613
614   x0 = bes;
615   x1 = storarm_base_w-bes;
616   y1 = storarm_base_h - bes;
617   y0 = bes;
618
619   for (pos=[ [x0, y1],
620              [x1, y1],
621              [x1, y0] ]) {
622     rotate([0,90,0])
623       translate([pos[0] - storarm_base_w,
624                  pos[1] - storarm_base_off_y, -storarm_base_d])
625       children();
626   }
627 }
628
629 module StorageArmRight(){ ////toplevel
630   shear = storarm_hookheight / (storarm_mainlen/2);
631
632   StorageArmDiagPart(-1, storarm_mainlen/2+1, shear, 0);
633   StorageArmDiagPart(storarm_mainlen/2-1, storarm_mainlen+1, shear/2,
634                      storarm_hookheight/2);
635
636   translate([0, storarm_hookheight, 0])
637     StorageArmDiagPart(storarm_mainlen, storarm_totlen,
638                        shear/2, -storarm_hookheight/2);
639
640   difference(){
641     union(){
642       hull(){
643         translate([-storarm_base_d, -storarm_base_off_y, storarm_base_w])
644           rotate([0,90,0])
645           linear_extrude(height=storarm_base_mind)
646           StorageArmBaseTemplate();
647         StorageArmDiagPart(-1, 0, shear, 0);
648       }
649       StorageArmAtMountingHoles(){
650         cylinder(r= storarm_screw_hole_head/2,
651                  h=10);
652       }
653     }
654     StorageArmAtMountingHoles(){
655       translate([0,0,-1])
656         cylinder(r= (storarm_screw_hole + storarm_screw_hole_slop)/2 ,
657                  h=20);
658       translate([0,0,storarm_under_hole])
659         cylinder(r= (storarm_screw_hole_head + storarm_screw_hole_head_slop)/2,
660                  h=20);
661     }
662   }
663 }
664
665 module StorageArmLeft(){ ////toplevel
666   mirror([1,0,0]) StorageArmRight();
667 }
668
669 module StorArmHoleTest(){ ////toplevel
670   sz = storarm_screw_hole_head + storarm_besides_hole*2;
671   intersection(){
672     StorageArmRight();
673     translate([-50, -storarm_base_off_y, -1])
674       cube([100, sz, sz+1]);
675   }
676 }
677
678
679 //----- filament guide spacer -----
680
681 guide_armdia = 15.0;
682 guide_armwidth = 10.2;
683 guide_armcorelen = 25.0;
684 guide_clipcirclethick = 10.0;
685
686 guidefilclip_outerdia = 22.8;
687
688 guidespacer_armslop = 0.75;
689 guidespacer_armlenslop = 1.05;
690
691 guidespacer_prongprotrude = 4;
692 guidespacer_thick = 1.6;
693
694 // calculated
695
696 guidespacer_armdia = guide_armdia + guidespacer_armslop;
697 guidespacer_armwidth = guide_armwidth + guidespacer_armslop;
698 guidespacer_len = guide_armcorelen - guide_clipcirclethick
699   + guidespacer_armlenslop;
700
701 guidespacer_wingheight = (guidefilclip_outerdia - guidespacer_armdia)/2;
702
703 module FilamentGuideArmTemplate(extra=0){
704   intersection(){
705     circle(r= (guidespacer_armdia/2) + extra);
706     square(center=true, [guidespacer_armwidth+extra*2,
707                          guidespacer_armdia + extra*2 + 10]);
708   }
709 }
710
711 module FilamentGuideSpacerInnerTemplate(){
712   FilamentGuideArmTemplate();
713   translate([0, -guidespacer_armdia/2])
714     square(center=true, [guidespacer_armwidth - guidespacer_prongprotrude,
715                          guidespacer_armdia]);
716 }
717
718 module FilamentGuideSpacer(){ ////toplevel
719   difference(){
720     union(){
721       linear_extrude(height= guidespacer_len)
722         FilamentGuideArmTemplate(extra= guidespacer_thick);
723       for (angle=[26, 60]) {
724         for (m=[0,1]) {
725           mirror([m,0,0]) {
726             rotate([0,0,angle]) {
727               hull(){
728                 for (t=[[0, guidespacer_wingheight],
729                         [guidespacer_len-1, -guidespacer_wingheight]])
730                   translate([0,0, t[0] + 0.5])
731                     cube([guidespacer_thick, guidespacer_armdia + t[1]*2,
732                       1],
733                          center=true);
734               }
735             }
736           }
737         }
738       }
739     }
740     translate([0,0,-1])
741       linear_extrude(height= guidespacer_len+5)
742       FilamentGuideSpacerInnerTemplate();
743   }
744 }
745
746
747 //----- replacement filament guide arm for TAZ-5 -----
748
749 guidearm_armslop = 0.25;
750 guidearm_armlenslop = 0.25;
751
752 guidearm_hookprotr = 4;
753 guidearm_hookprotrflat = 1;
754 guidearm_hookslope = 0.3;
755
756 guidearm_totallen = 60;
757
758 guidearm_screwplatesz = 12;
759 guidearm_screwplateth = 4;
760 guidearm_screwhole = 4 + 0.5;
761
762 guidearm_bendlen = 50;
763 guidearm_bendslot = 5;
764
765 guidearm_stopthick = 4;
766
767 // calculated
768
769 guidearm_armdia = guide_armdia - guidearm_armslop;
770 guidearm_armwidth = guide_armwidth - guidearm_armslop;
771 guidearm_armcorelen = guide_armcorelen + guidearm_armlenslop;
772
773 guidearm_base_z0 = -(guidearm_totallen - guidearm_armcorelen);
774
775 guidearm_realbendlen = min(guidearm_bendlen,
776                            guidearm_totallen - guidearm_screwplateth - 0.1);
777
778 module FilamentGuideArmStop(h){
779   for (ts=[-1,+1]) {
780     translate([ts * guidearm_hookprotr, 0,0])
781       cylinder(r=guidearm_armdia/2, h, $fn=80);
782   }
783 }
784
785 module FilamentGuideArmShaftPositive(){
786   r = guidearm_armdia/2;
787
788   translate([0,0, guidearm_base_z0+1])
789     cylinder(r=r, h= guidearm_totallen, $fn=80);
790   translate([0,0, guidearm_armcorelen]){
791     hull(){
792       FilamentGuideArmStop(guidearm_hookprotrflat);
793       translate([0,0, guidearm_hookprotr/guidearm_hookslope])
794         cylinder(r=r, h=guidearm_hookprotrflat, $fn=80);
795     }
796   }
797   mirror([0,0,1])
798     FilamentGuideArmStop(guidearm_stopthick);
799 }
800
801 module FilamentGuideArmBase(){
802   translate([0,0, guidearm_base_z0]){
803     difference(){
804       translate([0,0, guidearm_screwplateth/2])
805         cube(center=true,
806              [guidearm_armdia + guidearm_screwplatesz*2,
807               guidearm_armwidth,
808               guidearm_screwplateth]);
809       for (ts=[-1,+1]) {
810         translate([ts * (guidearm_armdia/2 + guidearm_screwplatesz/2),
811                    0,
812                    -20])
813           cylinder(r= guidearm_screwhole/2, h=40, $fn=20);
814       }
815     }
816   }
817 }
818
819 module FilamentGuideArm(){ ///toplevel
820   intersection(){
821     difference(){
822       FilamentGuideArmShaftPositive();
823       translate([-guidearm_bendslot/2,
824                  -50,
825                  -guidearm_realbendlen + guidearm_armcorelen])
826         cube([guidearm_bendslot,
827               100,
828               guidearm_realbendlen + 100]);
829     }
830     cube(center=true,
831          [guidearm_armdia*2,
832           guidearm_armwidth,
833           guidearm_totallen*3]);
834   }
835   FilamentGuideArmBase();
836 }
837
838 module FilamentGuideArmPrint(){ ////toplevel
839   rotate([90,0,0])
840     FilamentGuideArm();
841 }
842
843 module Demo(){
844   translate([-hubeffrad-30,50,0]) Hub();
845   ArmEnd();
846   translate([0,50,0]) FilamentCup();
847 }
848
849 //ArmEnd();
850 //FilamentCup();
851 //FilamentCupPair();
852 //CupSecuringClip();
853 //Hub();
854 //ArmExtender();
855 //Axle();
856 //AxleWasher();
857 //AxlePin();
858 //AxleFrictionWasher();
859 //StorageArmLeft();
860 //StorArmHoleTest();
861 //FilamentGuideSpacer();
862 //FilamentGuideArm();
863 //FilamentGuideArmPrint();
864 //Demo();