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