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