chiark / gitweb /
844971f5402bf4d1e6fb8b0383843beaacd6a655
[reprap-play.git] / sewing-table.scad.m4
1 // -*- C -*-
2
3 include <funcs.scad>
4 include <commitid.scad>
5
6 ply_th = 18;
7 ply_hole_dia = 15;
8 ply_edge_min = 10;
9
10 ply_hole_dia_real = 12;
11
12 tile_th = 3;
13 post_dia = 8;
14
15 post_shorter = 1;
16
17 $screw_dia = 3.168;
18 screw_big_dia = 3.6;
19 screw_big_len = 4.0;
20
21 round_edge_rad = 2.0;
22
23 round_cnr_rad = 10;
24
25 interlock_dia = 10;
26 interlock_fine = 0.66;
27
28 interlock_fine_slope = 1.0;
29 interlock_fine_lenslop = 1.0;
30
31 demo_slop = 0.1;
32
33 leg_height = 53.75 - 0.95;
34
35 leg_hole_dia = 5 + 0.75;
36 leg_big_dia = 37;
37 leg_bot_dia = 15;
38 leg_top_flat_z = 2;
39 leg_top_thick = 8;
40
41 leg_midspc_dia = 20;
42 leg_bot_thick = 8;
43 leg_bot_mid_dia = 12;
44
45 leg_fin_top_w = 3;
46 leg_fin_bot_w = 5;
47 leg_fin_bot_rad = 30;
48 leg_fin_bot_flat_z = 5;
49
50 leg_n_fins = 4;
51 leg_n_tubules = 4;
52 leg_tubule_dia = 4;
53
54 // cutout
55
56 machine_rear_to_front = 84 + 0.25 - 1.4;
57
58 cutout_l_end_y_front_slop = 0.5;
59 cutout_l_end_y_rear_slop = 0.5;
60
61 cutout_l_end_x = 22;
62 cutout_l_end_y = machine_rear_to_front;
63 cutout_l_end_new_x_slop = 1.4 - 1.95;
64 cutout_l_end_y_total = cutout_l_end_y
65   + cutout_l_end_y_front_slop + cutout_l_end_y_rear_slop;
66
67 tile02_tr = [-250, 0];
68 tile01_tr = [  0, 0];
69
70 cutout_tile01_y = 170 - 147 + cutout_l_end_y_front_slop;
71 cutout_tile11_y = cutout_l_end_y_total - cutout_tile01_y;
72
73 // front and rear curves
74
75 rearedge_len = 170 + 0.70;
76 frontedge_len = 170;
77
78 rearcurve_strt_len = 52;
79
80 rearcurve_z_slop = -0.50;
81
82 rearcurve_avoid_y = 35;
83
84 rearcurve_double_inrad = 26.10 + 8.04;
85
86 reartablet_z = 2.54;
87 reartablet_x = 5 + 1;
88 reartablet_y = 8;
89
90 frontcurve_side_skew = 3.5 / 72;
91 frontcurve_avoid_y = 70;
92 frontcurve_z_slop = 0.75;
93
94 frontcurve_strt_len = 50;
95 frontcurve_dualcurve_angle = 30;
96
97 teststrapslots_at = [ [ 110, 70 ], [ 110, -35 ],
98                       [ 180, 90 ],
99                       [ 190, -80 ], // do not change index of this one
100                       [   0, 70 ],  [  0, -35 ],
101                       ];
102
103 teststrap = [ 3, 5 ];
104 teststrap_peg = [7.5, 3.5];
105
106 ply_edge_hole_dist_real = 14;
107
108 // calculated
109
110 TEST = false;
111 JIG = false;
112
113 ply_edge_hole_dist = ply_edge_min + ply_hole_dia/2;
114
115 echo(str("HOLES IN PLY ctr dist from PLY edge = ", ply_edge_hole_dist));
116
117 hole_slop = (ply_hole_dia - post_dia)/2;
118 tile_hard_edge_hole_dist = ply_edge_hole_dist + hole_slop;
119
120 echo(str("HOLES IN PLY ctr dist from TILE HARD edge = ",
121          tile_hard_edge_hole_dist));
122
123 echo(str("HOLES IN PLY ctr dist from TILE ROUND edge = ",
124          tile_hard_edge_hole_dist + round_edge_rad));
125
126 thehd = [ tile_hard_edge_hole_dist, tile_hard_edge_hole_dist ];
127 thehd_tr = thehd;
128 thehd_tl = [ -thehd_tr[0], thehd_tr[1] ];
129 thehd_bl = -thehd_tr;
130 thehd_br = -thehd_tl;
131
132 tablet_z_slop = 1.00;
133
134 interlock_rad = interlock_dia/2;
135 interlock_negative_rad = interlock_rad + 0.125;
136
137 interlock_sq_adj = 0.2; // arbitrary
138
139 leg_fin_top_rad = sqrt( pow(leg_big_dia/2,2) -
140                         pow(leg_fin_top_w/2,2) );
141
142 leg_tubule_pos_rad = leg_big_dia/2 * 0.6;
143
144 m4_define(`POST_TCROSSSZ',
145           `2*( tile_hard_edge_hole_dist - test_edge + 1 )')
146
147 module Post(){
148   mirror([0,0,1]) {
149     if (!JIG) {
150       difference(){
151         cylinder(r= post_dia/2, h= tile_th + ply_th - post_shorter);
152         translate([0,0, tile_th]) {
153           cylinder(r= screw_big_dia/2, h= screw_big_len);
154           cylinder(r= $screw_dia/2, h= ply_th, $fn=20);
155         }
156       }
157     }
158     if (TEST) {
159       translate([0,0, tile_th/2]) {
160         cube([post_dia,      POST_TCROSSSZ, tile_th], center=true);
161         cube([POST_TCROSSSZ, post_dia,      tile_th], center=true);
162       }
163     }
164     if (JIG) {
165       translate([0,0, tile_th/2]) {
166         cube([POST_TCROSSSZ, POST_TCROSSSZ, tile_th], center=true);
167       }
168     }
169   }
170 }
171
172 module PostHole(){
173   if (JIG) {
174     translate([0,0,-5])
175       cylinder(r= post_dia/2 + jig_post_hole_slop, h=10);
176     translate([0,0, -jig_min_th])
177       cylinder(r= ply_hole_dia_real/2, h = 5);
178     for (rot=[0:90:270]) rotate(rot) {
179         translate([ ply_edge_hole_dist_real, 0, 0 ])
180           cube([ jig_pencil_rad*2, jig_pencil_slotlen, 20 ], center=true);
181       }
182   }
183 }
184
185 module Posts(posts) {
186   for (p= posts) {
187     translate(concat(p, [0]))
188       Post();
189   }
190 }
191 module PostHoles(posts) {
192   for (p= posts)  {
193     translate(concat(p, [0]))
194       PostHole();
195   }
196 }
197
198 module TileBase(botleft, topright){
199   size = topright - botleft;
200   botleft_post = botleft + thehd_tr;
201   topright_post = topright + thehd_bl;
202   difference(){
203     mirror([0,0,1])
204       translate(concat(botleft, [0]))
205       cube(concat(size, [tile_th]));
206     if (!(TEST || JIG)) {
207       cidsz = topright_post-botleft_post
208         + [-post_dia,-post_dia]
209         + [0, thehd[1]];
210       cidszr = [ min(cidsz[0],50), min(cidsz[1],50) ];
211       echo("CID",cidsz,cidszr);
212       translate( concat(botleft_post, [ -tile_th ])
213                  + 0.5 * [ post_dia, post_dia, 0 ]
214                  + 0.5 * concat( cidsz - cidszr, [ 0 ]) )
215         Commitid_BestCount_M(cidszr);
216     }
217     if ((TEST || JIG)) {
218       crossoff = tile_hard_edge_hole_dist + POST_TCROSSSZ/2;
219       cidsz = [ thehd[0], size[1] - 2*crossoff ];
220       cidszr = [ cidsz[0], min(cidsz[1], 50) ];
221       if (TEST)
222         translate( concat(botleft + [0, crossoff] + (cidsz-cidszr)/2, [0]) )
223           Commitid_BestCount(cidszr);
224       difference(){
225         mirror([0,0,1]) {
226           translate(concat(botleft + [test_edge,test_edge], [test_tile_th]))
227             cube(concat(size - [test_edge,test_edge]*2, [tile_th*2]));
228           translate(concat(botleft_post, [-1]))
229             cube(concat(topright_post-botleft_post, [tile_th+2]));
230         }
231         shufflesz = max(test_edge, tile_hard_edge_hole_dist)*2;
232         minkowski(){
233           MachineEnvelope();
234           cube(shufflesz, center=true);
235         }
236         if (JIG) {
237           translate([0,0,-20]) linear_extrude(height=20) {
238             for (diag=[[ +1, botleft                   ],
239                        [ -1, [topright[0], botleft[1]] ]]) {
240               translate(diag[1])
241                 rotate(atan2(size[1], diag[0] * size[0]))
242                 translate([0, -test_edge/2])
243                 square([vectorlen2d(size), test_edge]);
244             }
245           }
246         }
247       }
248     }
249   }
250 }
251
252 m4_dnl   R_EDGE(c,ix)
253 m4_dnl        c is from Rectangle_corners and
254 m4_dnl        ix is a corner number
255 m4_dnl    expands to two comma-separated corners:
256 m4_dnl    that denoted by ix, and the next one anticlockwise
257 m4_define(`R_EDGE',`$1[$2], $1[(($2)+1)%4]')
258
259 m4_dnl   R_CNR(c,ix)
260 m4_dnl        c is from Rectangle_corners and
261 m4_dnl        ix is a corner number
262 m4_dnl    expands to an array of corners as for RoundCorner
263 m4_define(`R_CNR',`[ $1[$2], $1[(($2)+1)%4], $1[(($2)+3)%4] ]')
264
265 m4_dnl  INREFFRAME(left_cnr, right_cnr, morevars) { body; }
266 m4_define(`INREFFRAME',`
267   length_vec = ($2) - ($1);
268   length = dist2d([0,0], length_vec);
269   length_uvec = length_vec / length;
270   ortho_uvec = [ -length_uvec[1], length_uvec[0] ];
271   m = [ [ length_uvec[0],  ortho_uvec[0], 0, ($1)[0], ],
272         [ length_uvec[1],  ortho_uvec[1], 0, ($1)[1], ],
273         [ 0,              0,              1,            0, ],
274         [ 0,              0,              0,            1, ] ];
275   $3
276   multmatrix(m)
277 ')
278
279 m4_dnl  INREFFRAME(left_cnr, right_cnr, morevars)
280 m4_dnl    INREFFRAME_EDGE { body; }
281 m4_define(`INREFFRAME_EDGE',`
282   translate([0,0, -round_edge_rad])
283 ')
284
285 module RoundEdge(left_cnr, right_cnr) {
286   INREFFRAME(left_cnr, right_cnr)
287     INREFFRAME_EDGE {
288     difference(){
289       rotate([0,90,0])
290         cylinder(r= round_edge_rad, h= length, $fn=50);
291       translate([-1, 0, -20])
292         cube([length+2, 20, 20]);
293     }
294   }
295 }
296
297 m4_define(`ROUNDCORNER_VARS',`
298   this_cnr = ci[0];
299   right_cnr = ci[1];
300   left_cnr = ci[2];
301   bigr= round_cnr_rad - round_edge_rad;
302   l_uvec = unitvector2d(left_cnr - this_cnr);
303   r_uvec = unitvector2d(right_cnr - this_cnr);
304   lp1 = left_cnr  + clockwise2d(l_uvec) * bigr;
305   lp2 = this_cnr  + clockwise2d(l_uvec) * bigr;
306   lp3 = this_cnr  - clockwise2d(r_uvec) * bigr;
307   lp4 = right_cnr - clockwise2d(r_uvec) * bigr;
308   ctr = line_intersection_2d(lp1,lp2,lp3,lp4);
309   ctr3 = concat(ctr,[0])
310 ')
311
312 module RoundCorner_selector(ci, adj) {
313   ROUNDCORNER_VARS;
314   intersection(){
315     union(){
316       INREFFRAME(ctr3,concat(lp1,[4])){
317         translate([0,0,-bigr]) linear_extrude(height=bigr*2) {
318           translate([-bigr*2 + adj, -bigr])
319             square([bigr*2, bigr*3]);
320         }
321       }
322     }
323     union(){
324       INREFFRAME(ctr3,concat(lp4,[0])){
325         translate([0,0,-bigr]) linear_extrude(height=bigr*2) {
326           translate([-bigr*2, -bigr*2])
327             square([bigr*2 + adj, bigr*3]);
328         }
329       }
330     }
331   }
332 }
333
334 module RoundCornerCut(ci) {
335   // ci should be [this_cnr, right_cnr, left_cnr]
336   // where right_cnr is to the right (ie, anticlockwise)
337   ROUNDCORNER_VARS;
338   difference(){
339     RoundCorner_selector(ci, -0.1);
340     translate(ctr3)
341       cylinder(center=true, h=20, r= bigr);
342   }
343 }
344
345 module RoundCornerAdd(ci) {
346   ROUNDCORNER_VARS;
347   intersection(){
348     RoundCorner_selector(ci, +0.1);
349     INREFFRAME_EDGE {
350       translate(ctr3){
351         rotate_extrude(convexity=10, $fn=50)
352           translate([bigr, 0])
353           difference(){
354           circle(r= round_edge_rad, $fn=50);
355           mirror([1,1])
356             square([20,20]);
357         }
358       }
359     }
360   }
361 }
362
363 module InterlockLobePlan(negative) {
364   r = negative ? interlock_negative_rad : interlock_rad;
365   ymir = negative ? 0 : 1;
366
367   dx = sqrt(3) * r;
368   $fn= 80;
369   translate([thehd[0], 0]){
370     mirror([0,ymir]){
371       circle(r=r);
372       difference(){
373         translate([-dx, -0.1])
374           square([ dx*2, r/2 + 0.1 ]);
375         for (xi = [-1, 1]) {
376           translate([ xi*dx, r ])
377             circle(r=r);
378         }
379       }
380     }
381   }
382 }
383
384 module InterlockEdgePlan(negative, nlobes, length, dosquare=true) {
385   for (lobei = [ 0 : nlobes-1 ]) {
386     lobex = (length - thehd[0]*2) * (lobei ? lobei / (nlobes-1) : 0);
387     translate([lobex, 0, 0]) {
388       InterlockLobePlan(negative);
389     }
390   }
391
392   if (dosquare) {
393     iadj = 0;
394     slotshorter = negative ? -0.1 : interlock_fine_lenslop;
395     mirror([0, negative])
396       translate([slotshorter, iadj])
397       square([length - slotshorter*2, interlock_fine + iadj*2]);
398   }
399 }
400
401 module InterlockEdge(left_cnr, right_cnr, negative=0, nlobes=2) {
402   plusth = negative * 1.0;
403   protr = interlock_fine + interlock_sq_adj;
404
405   z2 = -tile_th/2;
406   z1 = -tile_th/2 - protr / interlock_fine_slope;
407   z3 = -tile_th/2 + protr / interlock_fine_slope;
408
409   negsign = negative ? -1 : +1;
410   yprotr = negsign * protr;
411
412   INREFFRAME(left_cnr, right_cnr) {
413     for (vsect = [ // zs0            zs1      ys0,            ys1
414                   [ -tile_th-plusth, plusth,  0,              0],
415                   [ z1,              z2,      0, yprotr],
416                   [ z2,              z3,      yprotr, 0],
417                   ]) {
418       zs0 = vsect[0];
419       zs1 = vsect[1];
420       zsd = zs1-zs0;
421       ys0 = vsect[2];
422       ys1 = vsect[3];
423       ysd = ys1-ys0;
424       sl = ysd/zsd;
425       m = [ [ 1,0,   0,    0 ],
426             [ 0,1, -sl, -ys0 + negsign*interlock_sq_adj ],
427             [ 0,0,   1,  zs0 ],
428             [ 0,0,   0,    1 ] ];
429       multmatrix(m)
430         linear_extrude(height=zsd, convexity=10)
431         InterlockEdgePlan(negative, nlobes, length, !!ysd);
432     }
433   }
434 }
435
436 function TestPiece_holes2corners(holes) =
437   [ holes[0] + thehd_bl,
438     holes[1] + thehd_br,
439     holes[1] + thehd_tr,
440     holes[0] + thehd_tl ];
441
442 module TestPiece1(){ ////toplevel
443   holes = [ [-100, 0],
444             [   0, 0]
445             ];
446   corners = TestPiece_holes2corners(holes);
447   rcs = R_CNR(corners,0);
448   difference(){
449     union(){
450       TileBase(corners[0], corners[2]);
451       Posts(holes);
452       RoundEdge(corners[0], corners[1]);
453       RoundEdge(corners[3], corners[0]);
454     }
455     InterlockEdge(corners[1], corners[2], 1, nlobes=1);
456     RoundCornerCut(rcs);
457     PostHoles(holes);
458   }
459   RoundCornerAdd(rcs);
460 }
461
462 module TestPiece2(){ ////toplevel
463   holes = [ [   0, 0],
464             [  50, 0]
465             ];
466   corners = TestPiece_holes2corners(holes);
467   difference(){
468     union(){
469       TileBase(corners[0], corners[2]);
470       Posts(holes);
471       RoundEdge(corners[0], corners[1]);
472       InterlockEdge(corners[3], corners[0], 0, nlobes=1);
473     }
474     PostHoles(holes);
475   }
476 }
477
478 module TestDemo(){ ////toplevel
479   translate([ -thehd[0], 0 ])
480     color("blue")
481     TestPiece1();
482   translate([ +thehd[0] + demo_slop, 0 ])
483     TestPiece2();
484 }
485
486 module PostTestPiece(){ ////toplevel
487   hole_sizes = [2.8, 3.0, 3.1, 3.134, 3.168, 3.2, 3.3, 3.5];
488   nholes = len(hole_sizes)*2;
489   nrows = 4;
490   stride = post_dia*1.5;
491   rect_sz = stride * [ nrows,
492                        ceil(nholes/nrows) ];
493   corners = Rectangle_corners(-stride * 0.5 * [1,1], rect_sz);
494   difference(){
495     union(){
496       TileBase(corners[0], corners[2]);
497       RoundEdge(corners[0], corners[1]);
498       InterlockEdge(corners[3], corners[0], 0, nlobes=1);
499       for (i= [ 0: nholes-1 ]) {
500         $screw_dia = hole_sizes[ floor(i/2) ];
501         translate(stride * [ (nrows-1) - (i % nrows),
502                              floor(i / nrows),
503                              0
504                              ]) {
505           Posts([[0,0]]);
506           color("blue")
507             mirror([0,0,1])
508             translate([post_dia/2, -post_dia/2, 1])
509             cube([1, post_dia * (i / nholes), tile_th]);
510         }
511       }
512     }
513   }
514 }
515
516 module Machine_NewRearProfile(){
517   // figures copied out of xfig edit boxes
518   // best not to edit the posbox size if poss - just move it
519   posbox = 10 * ([7.2333,-14.1267] - [-16.2289,40.0289]); // box, Green
520   sideline = -10 * ([-6.2400,13.5600] - [-2.4467,28.2556]); // line, Blue
521   scaleline = 10 * dist2d([-1.1911,-20.4800], [-11.2600,4.0578]); // Green2
522   scaleline_mm = 12+5+10+5+3;
523   sh = -[abs(posbox[0]), abs(posbox[1])];
524   rot = atan2(-sideline[0], sideline[1]);
525   sc = scaleline_mm / scaleline;
526   //echo("SH",sh,rot,sc);
527   scale(sc) rotate(rot) translate(sh){
528     import("sewing-table-rear-profile.dxf", convexity=10); // spline, Pink3
529   }
530 }
531
532 module Machine_NewFrontProfile(){
533   // figures copied out of xfig edit boxes
534   // best not to edit the posbox size if poss - just move it
535   posbox = 10 * ([11.8022,8.0600] - [4.2044,19.1867]); // box, Green
536   refline = 10 * ([7.6778,16.7222] - [27.8689,17.6578]); // line, Blue
537   refline_mm = (11-1)*10;
538   sh = -[abs(posbox[0]), abs(posbox[1])];
539   rot = atan2(-refline[0], refline[1]);
540   sc = refline_mm / vectorlen2d(refline);
541   //echo("SH",sh,rot,sc);
542   mirror([1,0]) scale(sc) rotate(rot+90) translate(sh){
543     import("sewing-table-front-profile.dxf", convexity=10); // spline, Pink3
544   }
545 }
546
547 module Machine_NewEndProfile(){
548   // figures copied out of xfig edit boxes
549   // NB that y coords are reversed - xfig origin is at bottom left
550   posboxs = 10 * [[4.0400,17.7956], [11.6622,32.5511]]; // box, Pink3
551   refline = 10 * ([8.4000,22.6000] - [50.3000,22.2000]); // line, Blue
552   refline_mm = 10 * (11 - 2.5);
553   sidelines = 10 * [[[9.0889,20.6178], [8.9644,14.6889]],
554                     [[50.3800,21.9578], [50.1933,14.4933]]]; // lines, Blue3
555   baseline = 10 * [[8.4000,18.0822], [50.3000,17.6822]]; // line, Green2
556
557   rot_adj = -0.38;
558
559   posbox = [min(posboxs[0][0],posboxs[1][0]),
560             max(posboxs[0][1],posboxs[1][1])];
561
562   m4_define(`MNEP_ELP',
563      `line_intersection_2d(baseline[0],baseline[1],
564                            sidelines[$1][0],sidelines[$1][1])')
565   endline = [MNEP_ELP(0),MNEP_ELP(1)];
566
567   rot = atan2(-refline[1], -refline[0]);
568   sc = refline_mm / vectorlen2d(refline);
569   sh = (0.5 * (endline[0] + endline[1])) - posbox;
570
571   ellen = sc * dist2d(endline[0],endline[1]);
572   scy = cutout_l_end_y_total / ellen;
573
574   scale([scy,1]) scale(sc) rotate(rot + rot_adj) translate(-[sh[0],-sh[1]]){
575
576     mirror([0,1]){
577   //%translate(1 * (posboxs[0] - posbox)) square(50);
578   //%translate(1 * (posboxs[1] - posbox)) square(50);
579 //  %translate(1 * (baseline[0] - posbox)) square([50,10]);
580
581 //  %translate(1 * (endline[0] - posbox)) square([50,10]);
582 //  %translate(1 * (endline[1] - posbox)) square([50,10]);
583
584 //  %translate(1 * (sidelines[0][0] - posbox)) square([10,50]);
585 //  %translate(1 * (sidelines[0][1] - posbox)) square([10,50]);
586 //  %translate(1 * (sidelines[1][0] - posbox)) square([10,50]);
587 //  %translate(1 * (sidelines[1][1] - posbox)) square([10,50]);
588     }
589
590     import("sewing-table-end-profile.dxf", convexity=10); // spline, Pink3
591   }
592 }
593
594 module Machine_NewEndProfileDemo(){ ////toplevel
595     translate([0,5,0])                             Machine_NewEndProfile();
596     translate([0,5,1]) color("blue") mirror([1,0]) Machine_NewEndProfile();
597   mirror([0,1,0]){
598     translate([0,5, 0])                             Machine_NewEndProfile();
599     translate([0,5,-1]) color("blue") mirror([1,0]) Machine_NewEndProfile();
600   }
601 }
602
603 module Machine_NewArm(){
604   translate([0,0,-30]) linear_extrude(height=60) {
605     translate(tile01_tr + [ -cutout_l_end_x - cutout_l_end_new_x_slop,
606                             (-cutout_tile01_y + cutout_tile11_y)/2 ]){
607       rotate(-90){
608         hull(){
609           for (d=[0,400]) 
610             translate([0,d]) Machine_NewEndProfile();
611         }
612       }
613     }
614   }
615 }
616
617 module Machine_NewRearCurve(){
618   slant = atan2(4,210-10);
619   //echo("SL",slant);
620   translate([0,0, rearcurve_double_inrad]) rotate([slant,0,0]){
621     translate([ rearcurve_double_inrad,
622                 0,
623                 -rearcurve_double_inrad + 10 ]){
624       rotate([180,0,0]) rotate([0,0,90]) linear_extrude(height=30){
625         hull(){
626           Machine_NewRearProfile();
627           translate([0,-100]) Machine_NewRearProfile();
628         }
629       }
630     }
631     rotate([0,90,0]) rotate([90,0,0]) {
632       intersection(){
633         rotate_extrude(convexity=10, $fn=64)
634           rotate(90)
635           translate([ 0, -rearcurve_double_inrad ])
636           Machine_NewRearProfile();
637         translate([0,0,-500])
638           cube([500,500,1000]);
639       }
640     }
641     translate([1,0,-rearcurve_double_inrad])
642       rotate([0,-90,0]) rotate([0,0,-90])
643       linear_extrude(height= rearcurve_strt_len + 1)
644       Machine_NewRearProfile();
645   }
646 }
647
648 module Machine_Curves(){ ////toplevel
649   translate([ tile01_tr[0] - cutout_l_end_x + rearedge_len,
650               cutout_tile11_y,
651               0 ]){
652     //%cube([20,20,20]);
653     translate([ -reartablet_x,
654                 -1,
655                 -reartablet_z + tablet_z_slop])
656       mirror([0,0,1])
657       cube([ reartablet_x+1,
658              reartablet_y+1,
659              20 ]);
660   }
661   translate([ tile01_tr[0] - cutout_l_end_x + frontedge_len,
662               cutout_tile11_y,
663               frontcurve_z_slop ]){
664     translate([0, -machine_rear_to_front, 0])
665       multmatrix([[1, -frontcurve_side_skew, 0, 0],
666                   [0,  1,   0, 0],
667                   [0,  0,   1, 0],
668                   [0,  0,   0, 1]])
669       mirror([1,0,0]) rotate([0,-90,0])rotate([0,0,-90])
670       linear_extrude(height= 200)
671       Machine_NewFrontProfile();
672   }
673   translate([ tile01_tr[0] - cutout_l_end_x + rearedge_len,
674               cutout_tile11_y,
675               frontcurve_z_slop ]){
676     translate([ rearcurve_strt_len,
677                 0,
678                 rearcurve_z_slop ]){
679       Machine_NewRearCurve();
680     }
681   }
682 }
683
684 module TestStrapSlots(){
685   pegwidth = teststrap_peg[0];
686   for (pos = teststrapslots_at) {
687     echo("TSS",pos);
688     translate(concat(pos,[0]))
689       for (mx = [0,1]) mirror([mx,0,0]) {
690           translate([ pegwidth/2, -teststrap[1]/2, -20 ])
691             cube(concat(teststrap,[40]));
692         }
693   }
694 }
695
696 module TestStrapPeg_any(l){ cube(concat([l],teststrap_peg)); }
697
698 module TestStrapPeg_Short(){ ////toplevel
699   TestStrapPeg_any(35);
700 }
701
702 module TestStrapPeg_Long(){ ////toplevel
703   TestStrapPeg_any(60);
704 }
705
706 module Machine(){ ////toplevel
707   Machine_NewArm();
708   Machine_Curves();
709   if (TEST)
710     TestStrapSlots();
711 }
712
713 module MachineEnvelope(){
714   // used for testing
715   p_arm_bl = [-cutout_l_end_x, -cutout_tile01_y];
716   y_arm_t  = cutout_tile11_y;
717   p_crv_fl = p_arm_bl + [frontedge_len, -frontcurve_avoid_y];
718   y_crv_b  = y_arm_t + rearcurve_avoid_y;
719
720   translate([0,0,-50]) linear_extrude(height= 100){
721     translate(p_arm_bl) square([400, y_arm_t] - p_arm_bl);
722     translate(p_crv_fl) square([400, y_crv_b] - p_crv_fl);
723   }
724 }
725
726 module Leg(){ ////toplevel
727   difference(){
728     union(){
729       hull(){
730         mirror([0,0,1])
731           cylinder(r= leg_big_dia/2, h=leg_top_flat_z, $fn=100);
732         translate([0,0, -leg_top_thick])
733           cylinder(r= leg_bot_dia/2, height=1, $fn=100);
734       }
735       if (!TEST)
736         translate([0,0,-leg_height])
737           cylinder(r= leg_bot_mid_dia/2, h=leg_bot_thick);
738       for (rot=[0: 360/leg_n_fins : 359]) rotate(rot) {
739           hull(){
740             mirror([0,0,1]) translate([0, -leg_fin_top_w/2, 0])
741               cube([ leg_fin_top_rad - 0.1,
742                      leg_fin_top_w,
743                      1 ])
744               ;
745             translate([0, -leg_fin_bot_w/2, -leg_height])
746               cube([ leg_fin_bot_rad,
747                      leg_fin_bot_w,
748                      leg_fin_bot_flat_z ]);
749           }
750         }
751     }
752     mirror([0,0,1]) translate([0,0,-1])
753       cylinder(r= leg_hole_dia/2,
754                h= (!TEST ? leg_height+2 : leg_height/2),
755                $fn=30);
756     mirror([0,0,1]) translate([0,0,leg_top_thick - 0.1])
757       hull(){
758         cylinder(r= (!TEST ? leg_midspc_dia/2 : 0.1),
759                  h= leg_height - leg_top_thick - leg_bot_thick + 0.2,
760                  $fn=30);
761         if (TEST)
762           cylinder(r= leg_midspc_dia/2,
763                    h= leg_height - leg_top_thick - leg_bot_thick
764                       + (!TEST ? 0.2 : -leg_midspc_dia/2),
765                    $fn=30);
766       }
767     if (!TEST)
768       for (rot=[45: 360/leg_n_tubules : 359]) rotate(rot) {
769           mirror([0,0,1]) translate([ leg_tubule_pos_rad, 0, -1])
770             cylinder(r= leg_tubule_dia/2, h=leg_height+2, $fn=20);
771         }
772   }
773 }
774
775 function Rectangle_corners(c0, sz) =
776   // returns the corners of a rectangle from c0 to c0+sz
777   // if sz is positive, the corners are anticlockwise starting with c0
778   [ c0 + [ 0,     0     ],
779     c0 + [ sz[0], 0     ],
780     c0 + [ sz[0], sz[1] ],
781     c0 + [ 0,     sz[1] ] ];
782
783 function Rectangle_corners2posts(c) =
784   [ c[0] + thehd_tr,
785     c[1] + thehd_tl,
786     c[2] + thehd_bl,
787     c[3] + thehd_br ];
788
789 module Rectangle_TileBase(c) { TileBase(c[0], c[2]); }
790
791 function Posts_interpolate_one(c0,c1) = [c0, (c0+c1)/2, c1];
792
793 module Tile02(){ ////toplevel
794   sz = [100,170];
795   c0 = tile02_tr + -sz;
796   c = Rectangle_corners(c0, sz);
797   posts = Rectangle_corners2posts(c);
798   rcs = R_CNR(c,0);
799   difference(){
800     union(){
801       Rectangle_TileBase(c);
802       Posts(posts);
803       RoundEdge(R_EDGE(c,0));
804       RoundEdge(R_EDGE(c,3));
805       InterlockEdge(R_EDGE(c,2), 0);
806     }
807     InterlockEdge(R_EDGE(c,1), 1);
808     RoundCornerCut(rcs);
809     PostHoles(posts);
810   }
811   RoundCornerAdd(rcs);
812 }
813
814 module Tile12(){ ////toplevel
815   sz = [100,250];
816   c0 = tile02_tr + [-sz[0], 0];
817   c = Rectangle_corners(c0, sz);
818   posts = Rectangle_corners2posts(c);
819   rcs = R_CNR(c,3);
820   difference(){
821     union(){
822       Rectangle_TileBase(c);
823       Posts(posts);
824       RoundEdge(R_EDGE(c,2));
825       RoundEdge(R_EDGE(c,3));
826     }
827     InterlockEdge(R_EDGE(c,0), 1);
828     InterlockEdge(R_EDGE(c,1), 1);
829     RoundCornerCut(rcs);
830     PostHoles(posts);
831   }
832   RoundCornerAdd(rcs);
833 }
834
835 tile_01_11_cnr = tile01_tr + [-cutout_l_end_x, 0];
836 tile_11_10_cnr = tile01_tr + [0, cutout_tile11_y];
837 tile_01_00_cnr = tile01_tr - [0, cutout_tile01_y];
838
839 module Tile11(){ ////toplevel
840   sz = [250,250];
841   c0 = tile01_tr + [-sz[0],0];
842   c = Rectangle_corners(c0, sz);
843   cnr_posts = Rectangle_corners2posts(c);
844   posts = concat(
845                  Posts_interpolate_one(cnr_posts[0],
846                                        cnr_posts[1] - [cutout_l_end_x, 0]),
847                  [ cnr_posts[1] + [0, cutout_tile11_y],
848                    cnr_posts[2],
849                    cnr_posts[3]
850                    ]);
851   difference(){
852     union(){
853       Rectangle_TileBase(c);
854       Posts(posts);
855       RoundEdge(R_EDGE(c,2));
856       InterlockEdge(R_EDGE(c,3));
857     }
858     InterlockEdge(c[0], tile_01_11_cnr, 1);
859     InterlockEdge(tile_11_10_cnr, c[2], 1);
860     PostHoles(posts);
861     Machine();
862   }
863 }    
864
865 module Tile01(){ ////toplevel
866   sz = [250,170];
867   c0 = tile01_tr + -sz;
868   c = Rectangle_corners(c0, sz);
869   cnr_posts = Rectangle_corners2posts(c);
870   posts = concat(
871                  Posts_interpolate_one(R_EDGE(cnr_posts,0)),
872                  [ cnr_posts[2] + [0, -cutout_tile01_y] ],
873                  Posts_interpolate_one(cnr_posts[2] - [cutout_l_end_x, 0],
874                                        cnr_posts[3])
875                  );
876   difference(){
877     union(){
878       Rectangle_TileBase(c);
879       Posts(posts);
880       RoundEdge(R_EDGE(c,0));
881       InterlockEdge(tile_01_11_cnr, c[3]);
882       InterlockEdge(R_EDGE(c,3));
883     }
884     PostHoles(posts);
885     InterlockEdge(c[1], tile_01_00_cnr, 1);
886     Machine();
887   }
888 }    
889
890 module Tile10(){ ////toplevel
891   sz = [250,250];
892   c0 = tile01_tr + [0,0];
893   c = Rectangle_corners(c0, sz);
894   cnr_posts = Rectangle_corners2posts(c);
895   cty = cutout_tile11_y;
896   rcy = cty + rearcurve_avoid_y;
897   posts = [ cnr_posts[0] + [ 0,                             cty ],
898             cnr_posts[1] + [ -sz[0] + rearedge_len - cutout_l_end_x, cty ],
899             cnr_posts[1] + [ 0,                             rcy ],
900             cnr_posts[2],
901             cnr_posts[3] ];
902   rcs = R_CNR(c,2);
903   difference(){
904     union(){
905       Rectangle_TileBase(c);
906       Posts(posts);
907       RoundEdge(R_EDGE(c,1));
908       RoundEdge(R_EDGE(c,2));
909       InterlockEdge(c[3], tile_11_10_cnr);
910     }
911     PostHoles(posts);
912     RoundCornerCut(rcs);
913     Machine();
914   }
915   RoundCornerAdd(rcs);
916 }
917
918 module Tile00(){ ////toplevel
919   sz = [250,170];
920   c0 = tile01_tr + [0,-sz[1]];
921   c = Rectangle_corners(c0, sz);
922
923   // the edge c[1]..c[2] needs a diagonal chunk, from c1bis to c2bis
924   c2bis = [ -cutout_l_end_x + frontedge_len + frontcurve_strt_len, c[2][1] ];
925   c1bis = [ c[1][0],
926             c[2][1] -
927             (c[2][0] - c2bis[0]) * tan(90 - frontcurve_dualcurve_angle) ];
928
929   cnr_posts = Rectangle_corners2posts(c);
930   cty = cutout_tile01_y;
931   rcy = cty + frontcurve_avoid_y;
932   posts = [ cnr_posts[0],
933             cnr_posts[1],
934             0.5 * (cnr_posts[0] + cnr_posts[1]),
935             cnr_posts[2] + [ 0,                             -rcy ],
936             cnr_posts[2] + [ -sz[0] + frontedge_len - cutout_l_end_x, -cty ],
937             cnr_posts[3] + [ 0,                             -cty ]
938             ];
939   rcs = R_CNR(c,1);
940   rc2 = [c1bis,c2bis,c[1]];
941   difference(){
942     union(){
943       difference(){
944         union(){
945           Rectangle_TileBase(c);
946           Posts(posts);
947           RoundEdge(R_EDGE(c,0));
948           RoundEdge(c[1], c1bis);
949           InterlockEdge(tile_01_00_cnr, c[0]);
950         }
951         RoundCornerCut(rcs);
952         translate([0,0,-20]) linear_extrude(height=40) {
953           polygon([ c1bis, c1bis + [50,0], c2bis + [50,0], c2bis ]);
954         }
955       }
956       RoundEdge(c1bis, c2bis);
957     }
958     Machine();
959     PostHoles(posts);
960     RoundCornerCut(rc2);
961   }
962   RoundCornerAdd(rcs);
963   RoundCornerAdd(rc2);
964 }
965
966 module FitTest_general(c0,sz, dobrace=false, bracexx=0){
967   c = Rectangle_corners(c0, sz);
968   brace = [7,7,9];
969   bsz = sz + [bracexx,0,0];
970   difference(){
971     union(){
972       Rectangle_TileBase(c);
973       if (dobrace) {
974         translate(concat(c0, [-brace[2] + 0.1])){
975           difference(){
976             cube(concat(bsz, [brace[2]]) - [5,0,0]);
977             translate(brace + [0,0, -25])
978               cube(concat(bsz, [50]) - brace*2 + [10,0,0]);
979           }
980         }
981       }
982       RoundEdge(R_EDGE(c,1));
983     }
984     Machine();
985   }
986 }
987
988 module FitTest_PairLink(cut=false){ ////toplevel
989   cy0=-55; cy1=85; cx=132;
990   bar = [10,10];
991   legrad = 12;
992   footrad_min = 1; footrad_max = 4; footrad_depth = 5;
993   strap = [3,5];
994   adj_neg_slop = 1.0;
995   bar_z_slop = 1.75;
996
997   // calculated
998   straphole_x_max = legrad/sqrt(2) + footrad_max;
999   dz = cut ? adj_neg_slop : 0;
1000
1001   translate([cx - bar[0]/2, cy0, dz + bar_z_slop])
1002     cube([bar[0], cy1-cy0, bar[1] - bar_z_slop]);
1003
1004   for (endy=[cy0,cy1]) {
1005     $fn=32;
1006     translate([cx,endy,dz]){
1007       // feet
1008       for (rot=[45:90:315]) rotate(rot) {
1009         translate([legrad,0,0]){
1010           hull(){
1011             cylinder(r= footrad_max, h=1);
1012             translate([0,0,-footrad_depth])
1013               cylinder(r= footrad_min, h=1);
1014           }
1015           if (cut)
1016             translate([0,0,-10])
1017             cylinder(r= footrad_min +
1018                      adj_neg_slop * (footrad_max-footrad_min)/footrad_depth,
1019                      h=20);
1020         }
1021       }
1022       // legs
1023       for (rot=[45,135]) rotate(rot) {
1024         hull(){
1025           for (s=[-1,+1]){
1026             translate([s*legrad,0,0])
1027               cylinder(r= footrad_max, h=bar[1]);
1028           }
1029         }
1030       }
1031       // strap holes
1032       if (cut) {
1033         for (rot=[0,180]) rotate(rot) {
1034             translate([ straphole_x_max - strap[0]/2, 0,0 ])
1035               cube(concat(strap,[20]), center=true);
1036           }
1037       }
1038     }
1039   }
1040 }
1041
1042 module FitTest_RearCurve(){ ////toplevel
1043   difference(){
1044     FitTest_general([100,0], [180,100]);
1045     FitTest_PairLink(true);
1046     TestStrapSlots();
1047   }
1048 }
1049
1050 module FitTest_FrontCurve(){ ////toplevel
1051   p0 = [100,-80];
1052   sz = [180,80];
1053   difference(){
1054     intersection() {
1055       Tile00();
1056       translate([0,0,-8]) linear_extrude(height=18) {
1057         translate(p0) square(sz);
1058         translate(teststrapslots_at[3])
1059           scale(2* [ teststrap_peg[0], teststrap[1] ])
1060           circle(r=1, $fn=20);
1061       }
1062     }
1063     FitTest_PairLink(true);
1064     TestStrapSlots();
1065   }
1066 }
1067
1068 module FitTest_Entire(){ ////toplevel
1069   p0 = [-33,-80];
1070   szrear = [263,180];
1071   szfront = [243,szrear[1]];
1072   difference(){
1073     FitTest_general(p0, szrear, dobrace=true, bracexx=0);
1074     FitTest_PairLink(true);
1075     translate(concat(p0,[0]) + [szfront[0],-10,-40])
1076       cube([100, -p0[1], 80]);
1077     TestStrapSlots();
1078   }
1079   intersection(){
1080     FitTest_RearCurve();
1081     translate(concat(p0,[-20])) cube(concat(szrear,[40]));
1082   }
1083   FitTest_FrontCurve();
1084 }
1085
1086 module FitTest_EntireDemo(){ ////toplevel
1087   FitTest_Entire();
1088   //%Tile00();
1089 }
1090
1091 module FitTest_EndEnd(){ ////toplevel
1092   p0 = [-30,-32];
1093   sz = [156,81] - p0;
1094   sz2 = [136,68] - p0;
1095   difference(){
1096     FitTest_general(p0, sz);
1097     translate([ p0[0] -1, p0[1]+sz2[1], -10])
1098       cube([ sz2[0] +1, 50, 20 ]);
1099   }
1100 }
1101
1102 module FitTest_PairDemo(){ ////toplevel
1103   sh=[-90,-15,0];
1104   translate(sh){
1105     FitTest_PairLink();
1106     %FitTest_FrontCurve();
1107     %FitTest_RearCurve();
1108   }
1109   rotate([0,0,180]){
1110     translate(sh){
1111       difference(){
1112         union(){
1113           FitTest_FrontCurve();
1114           FitTest_RearCurve();
1115         }
1116         #FitTest_PairLink(true);
1117       }
1118     }
1119   }
1120 }
1121
1122 module RoundCornerDemo_plat(cnr){
1123   mirror([0,0,1]) linear_extrude(height=1) polygon(cnr);
1124 }
1125
1126 module RoundCornerDemo(){ ////toplevel
1127   cnr = [ [-2,-3], [13,-3], [-12,9] ];
1128   translate([0,25,0]) RoundCornerDemo_plat(cnr);
1129   translate([25,0,0]) RoundCornerAdd(cnr);
1130   translate([-25,0,0]) RoundCornerCut(cnr);
1131   translate([0,-25,0]) RoundCorner_selector(cnr, 0);
1132   difference(){
1133     RoundCornerDemo_plat(cnr);
1134     RoundCornerCut(cnr);
1135   }
1136   RoundCornerAdd(cnr);
1137 }
1138
1139 module Demo(){ ////toplevel
1140   translate(demo_slop*[-2,1]) color("blue") Tile12();
1141   translate(demo_slop*[-2,0]) color("red")  Tile02();
1142   translate(demo_slop*[-2,1]) color("orange") Tile11();
1143   translate(demo_slop*[-2,0]) color("purple") Tile01();
1144   translate(demo_slop*[-3,1]) color("blue")   Tile10();
1145   translate(demo_slop*[-3,0]) color("red")    Tile00();
1146   %Machine();
1147   // Can also do this, to print reference sheet:
1148   //  load this into openscad
1149   //  select Ctrl-4 view, view all, scale appropriately
1150   //  import sewing-table,Demo-flat.png
1151   //  pngtopnm <sewing-table,Demo-flat.png | ppmbrighten -s -50 -v +100 >t.pnm
1152   //  lpr t.pnm
1153 }
1154   
1155 //TestPiece1();
1156 //TestPiece2();
1157 //Demo();
1158
1159 //Machine_NewRearProfile();
1160 //Machine_NewRearCurve();
1161 //Machine_NewFrontProfile();
1162 //Machine_NewEndProfile();
1163 //Machine_NewEndProfileDemo();
1164 //Machine_Curves();
1165 //Machine();
1166 //FitTest();
1167 //MachineEnvelope();