fairphone-case.scad

   1 // -*- C -*-
   2
   3 include <utils.scad>
   4
   5 phone = [ 75.0, 145.0 ];
   6
   7 bumper = [ 0.250, -0.025 ];
   8 // ^ One side.  Overall size is increased by twice this.
   9 // If no bumpers, is the gap around the phone.
  10
  11 phone_cnr_rad = 6.0;
  12
  13 button_cutout_depth = 9;
  14
  15 phone_edge_thick = 9.0;
  16 phone_total_thick = 12.0;
  17 phone_backside_slope_inner = 1.5; // larger means shallower
  18 phone_backside_slope_outer = 1.0; // larger means shallower
  19
  20 camera_pos_tl = [  6.450, 12.750 ]; // measured from tl corner
  21 camera_pos_br = [ 22.300, 37.600 ]; // tl/br as seen from back
  22
  23 jack_pos = [ 13.92, 7.96 ];
  24 jack_dia = 9.1 + .5; // some jack I had lying around
  25
  26 noisecancelmic_pos = [ 19.54, 7.37 ];   // from rhs
  27 noisecancelmic_dia = 1.75;
  28
  29 fingerpushhole_dias = [ 14, 17 ];
  30
  31 rearspeaker_pos_bl = [ 14.92, 18.72 ];
  32 rearspeaker_size   = [  3.76,  7.36 ];
  33
  34 case_th_bottom = 2.5;
  35 case_th_lid = 2.5;
  36 case_th_side = 2;
  37 case_th_lip = 1.2;
  38
  39 case_struts_count = 6;
  40 case_struts_solid_below = 1.00;
  41 case_struts_solid_above = 0.75;
  42 case_struts_width = 0.10;
  43
  44 keeper_th_z = 0.75;
  45 keeper_th_x = 0.75;
  46 keeper_inner_width = 2.75;
  47 keeper_inner_height = 2.75;
  48 keeper_slant_slope = 2; // larger means steeper
  49
  50 keeper_gap_z_top = 0.25;
  51 keeper_gap_z_bot = 0.75;
  52 keeper_gap_x     = 0.25;
  53 keeper_gap_x_holes = 0.75;
  54
  55 case_lip = 1.25;
  56
  57 lid_gap_x = 0.25;
  58 lid_gap_z = 0.25;
  59 lid_lip = 1.75;
  60
  61 foldover_gap = 0.50;
  62 foldover_hinger_gap = 0.50;
  63
  64 hingescrew_nut_dia = 4.72 + 0.50; // washer, actually
  65 hinger_th = 2;
  66
  67 $fa = 5;
  68 $fs = 0.1;
  69
  70 button_l_fudge = 4.4;
  71 buttonishleg_default_l_is_fudge = 10;
  72
  73 strut_min_at_end = 1.5;
  74
  75 rearspeaker_gap    = [ 1.0, 1.0 ]; // each side
  76
  77 // ---------- calculated ----------
  78
  79 phone_width =  (phone + bumper*2)[0];
  80 phone_height = (phone + bumper*2)[1];
  81
  82 inside_br = [phone_width, -phone_height];
  83
  84 //echo(camera_pos_tl + bumper,
  85 //     camera_pos_br + bumper);
  86
  87 // ----- could be changed -----
  88 lid_buttoncover_gap = lid_gap_x;
  89 lid_buttoncover_overlap = case_th_lip + keeper_gap_z_top;
  90
  91 phone_backside_slope_thick = phone_total_thick - phone_edge_thick;
  92
  93 //lid_lip_overlap_width xxx bad name = ;
  94 //lid_lip_inner_slope = [ 5, 5 ]; // xxx
  95
  96 epp0 = [0,0];
  97 epp1 = [0, -phone_edge_thick];
  98 epp2i = epp1 + phone_backside_slope_thick * [ phone_backside_slope_inner, -1 ];
  99 epp2o = epp1 + phone_backside_slope_thick * [ phone_backside_slope_outer, -1 ];
 100 epp3 = epp2i + [10, 0];
 101 epp5 = epp0 + [0,1] * (keeper_th_z + keeper_gap_z_top + case_lip);
 102 epp4 = epp5 + [-1,0] * case_th_side;
 103
 104 kppe = [0,0];
 105 kppd = kppe + [1,0] * keeper_inner_width;
 106 kppc = kppd + [0,1] * keeper_th_z;
 107 kppb = [ kppe[0] - keeper_th_x, kppc[1] ];
 108 kppf = kppe - [0,1] * keeper_inner_height;
 109 kppa = [ kppb[0], kppf[1] ];
 110
 111 lpp10 = [ epp5[0] + lid_gap_x, kppc[1] + lid_gap_z ];
 112 lpp11 = [ lpp10[0],            epp5[1] + lid_gap_z ];
 113
 114 lp_r12 = case_th_lid - (lpp11[1] - lpp10[1]);
 115
 116 lpp12 = [ epp4[0] + lp_r12,    lpp11[1] ];
 117 lpp13 = [ lpp12[0],            lpp12[1] + lp_r12 ];
 118
 119 // button profile
 120 bppM = epp4 + [0,5];
 121 bppN = [ 0.5 * (epp0[0] + epp4[0]), bppM[1] ];
 122 bppR = [ bppN[0] + lid_buttoncover_gap, -button_cutout_depth ];
 123 bppS = [ epp1[0], bppR[1] ];
 124 bppQ = [ bppM[0], bppR[1] - lid_buttoncover_overlap ];
 125 bppP = bppQ + [0,1] * lid_buttoncover_gap;
 126 bppO = [ bppN[0], bppP[1] ];
 127 bppL = lpp10 + [5,0];
 128 bppK = [ bppL[0], bppN[1] ];
 129 bppJ = [ bppN[0], bppL[1] ];
 130
 131 // hinge plan
 132 hp_rn = hingescrew_nut_dia;
 133 hp_r2 = hp_rn + hinger_th;
 134
 135 hppU = lpp13;
 136 hppS = epp2o[1] + [0,-1] * case_th_bottom;
 137 hp_k = 0.5 * (hppU[1] - hppS[1] + foldover_gap);
 138
 139 hppM = [ epp4[0] - foldover_hinger_gap - hp_r2,
 140          0.5 * (hppU + hppS)[1] ];
 141 hppT = hppM + 0.5 * [0,+1] * hp_k;
 142 hppB = hppM + 0.5 * [0,-1] * hp_k;
 143
 144 // ---------- modules ----------
 145
 146 module KeeperProfile(slant=0){
 147   use_e = kppe + [0,-1] * slant * keeper_inner_width / keeper_slant_slope;
 148   polygon([use_e, kppd, kppc, kppb, kppa, kppf]);
 149 }
 150
 151 module EdgeProfile(){
 152   difference(){
 153     hull(){
 154       translate(epp3) square(case_th_bottom*2, center=true);
 155       circleat(epp2o, r=case_th_bottom);
 156       circleat(epp1, r=case_th_side);
 157       rectfromto(epp0, epp4);
 158     }
 159     polygon([ epp5 + [0,10],
 160               epp1,
 161               epp2i,
 162               epp3 + [10,0] ]);
 163   }
 164 }
 165
 166 module LidEdgeProfile(){
 167   polygon([ lpp10,
 168             lpp11,
 169             lpp12,
 170             lpp13,
 171             lpp13 + [10, 0],
 172             lpp10 + [10, 0]
 173             ]);
 174   intersection(){
 175     circleat(lpp12, r=lp_r12);
 176     rectfromto( lpp12 + [-10,   0],
 177                 lpp12 + [+10, +10] );
 178   }
 179 }
 180
 181 module ButtonCoverProfile(){
 182   intersection(){
 183     polygon([ bppM, bppP, bppO, bppJ, bppL, bppK ]);
 184     hull(){
 185       EdgeProfile();
 186       LidEdgeProfile();
 187     }
 188   }
 189 }
 190
 191 module ButtonPlan(l, deep, cut){
 192   epsilon =
 193     (cut  ? 0 : lid_buttoncover_gap);
 194
 195   delta =
 196     (deep ? lid_buttoncover_overlap : 0);
 197
 198   C = [0,0]; // by definition
 199   T = [ 0, epp4[1] ];
 200   G = T + [0,10];
 201
 202   B0 = C + [0,-1] * button_cutout_depth;
 203   B1 = B0 + [0,1] * epsilon;
 204
 205   r0 = 0.5 * (T[1] - B0[1]);
 206   A = [  -(l + button_l_fudge)/2 + r0, 0.5 * (T[1] + B0[1]) ];
 207   H = A + [0,-1] * delta;
 208
 209   D = A + [-2,0] * r0;
 210   F = D + [0,10];
 211
 212   E0 = 0.5 * (D + A);
 213   E1 = E0 + [1,0] * epsilon;
 214
 215   I0 = [ E0[0], H[1] ];
 216   I1 = [ E1[0], H[1] ];
 217
 218   hull(){
 219     for (m=[0,1]) mirror([m,0])
 220       circleat(H, r0 - epsilon);
 221   }
 222   for (m=[0,1]) mirror([m,0]) {
 223     difference(){
 224       polygon([ E1,
 225                 I1,
 226                 H,
 227                 B1,
 228                 G,
 229                 F,
 230                 D
 231                 ]);
 232       circleat(D, r0 + epsilon);
 233     }
 234   }
 235 }
 236
 237 module CaseBase_rhsflip(yn=[0,1]) {
 238   for ($rhsflip=yn) {
 239     translate([phone_width/2, 0, 0])
 240       mirror([$rhsflip,0,0])
 241       translate([-phone_width/2, 0, 0])
 242       children();
 243   }
 244 }
 245
 246 module CaseBase_botflip(yn=[0,1]) {
 247   for ($botflip=yn) {
 248     translate([0, -phone_height/2, 0])
 249       mirror([0, $botflip, 0])
 250       translate([0, phone_height/2, 0])
 251       children();
 252   }
 253 }
 254
 255 module AroundEdges(fill_zstart, fill_th, fill_downwards=0){
 256   // sides
 257   CaseBase_rhsflip(){
 258     translate([0, -phone_cnr_rad, 0])
 259       rotate([90,0,0])
 260       linear_extrude(height = phone_height - phone_cnr_rad*2)
 261       children(0);
 262   }
 263   // corners
 264   CaseBase_rhsflip() CaseBase_botflip() {
 265     translate([+1,-1] * phone_cnr_rad)
 266       intersection(){
 267         rotate_extrude()
 268           intersection(){
 269             mirror([1,0,0])
 270               translate([-1,0] * phone_cnr_rad)
 271               children(0);
 272             rectfromto([0,-20],[10,20]);
 273           }
 274         translate([-10, 0, -20] + 0.01 * [+1,-1, 0] )
 275           cube([10,10,40]);
 276       }
 277   }
 278   // top and bottom
 279   CaseBase_botflip(){
 280     translate([ phone_width - phone_cnr_rad, 0,0 ])
 281       rotate([90,0,-90])
 282       linear_extrude(height = phone_width - phone_cnr_rad*2)
 283       children(0);
 284   }
 285   // fill
 286   translate([0,0, fill_zstart])
 287     mirror([0,0, fill_downwards])
 288     linear_extrude(height = fill_th)
 289     rectfromto([+1,-1] * phone_cnr_rad,
 290                [phone_width, -phone_height] + [-1,+1] * phone_cnr_rad);
 291 }
 292
 293 module CaseAperture(pos, dia, $fn) {
 294   theta = 180/$fn;
 295   translate([ pos[0] + bumper[0],
 296               -epp2i[0],
 297               -pos[1] ])
 298     rotate([-90, theta, 0])
 299     cylinder(r = dia/2 / cos(theta),
 300              h = 60);
 301 }
 302
 303 module SideButton(y, y_ref_sign, l){
 304   // y_ref_sign:
 305   //   +1  measured from top    of actual phone to top    of button
 306   //   -1  measured from bottom of actual phone to bottom of button
 307   //    0  y is centre of button in coordinate system
 308   $button_l= l;
 309   eff_y = y_ref_sign > 0 ?         -bumper [1] -y -l/2 :
 310           y_ref_sign < 0 ? (-phone -bumper)[1] +y +l/2 :
 311           y;
 312   echo(eff_y);
 313   translate([0, eff_y, 0])
 314     children();
 315 }
 316
 317 module LidButtonishLeg(y, y_ref_sign, l=buttonishleg_default_l_is_fudge) {
 318   $button_leg_only = true;
 319   SideButton(y, y_ref_sign, l) children();
 320 }
 321
 322 module Buttons(){
 323   CaseBase_rhsflip([1]) SideButton(15.580, +1, 8.9) children(); // power
 324   CaseBase_rhsflip([1]) SideButton(48.700, -1, 8.920) children(); // camera
 325   CaseBase_rhsflip([0]) SideButton(30.800, +1, 21.96) children(); // volume
 326   CaseBase_rhsflip(   ) LidButtonishLeg(20, -1) children();
 327 //  CaseBase_rhsflip([0]) LidButtonishLeg(20, +1, 20) children();
 328 }
 329
 330 module Struts(x_start, z_min, th){
 331   // if th is negative, starts at z_min and works towards -ve z
 332   // and object should then be printed other way up
 333   for (i= [1 : 1 : case_struts_count]) {
 334     translate([0,
 335                0,
 336                z_min])
 337       mirror([0,0, th<0 ? 1 : 0])
 338       translate([0,
 339                  -phone_height * i / (case_struts_count+1),
 340                  case_struts_solid_below])
 341       linear_extrude(height= abs(th)
 342                      -(case_struts_solid_below+case_struts_solid_above))
 343       rectfromto([               x_start, -0.5 * case_struts_width ],
 344                  [ phone_width - x_start, +0.5 * case_struts_width ]);
 345   }
 346 }
 347
 348 module OrdinaryRearAperture(rhs,bot, pos){
 349   CaseBase_rhsflip(rhs) CaseBase_botflip(bot)
 350     linextr(-20, 20)
 351     mirror([0,1])
 352     translate(pos + bumper)
 353     children();
 354 }
 355
 356 module OrdinaryRearApertures(){
 357   // rear speaker
 358   OrdinaryRearAperture(1,1, rearspeaker_pos_bl)
 359     rectfromto(-rearspeaker_gap,
 360                rearspeaker_size + rearspeaker_gap);
 361
 362   // finger hole to remove phone
 363   OrdinaryRearAperture(1,0, [ fingerpushhole_dias[0]/2 + epp2i[0],
 364                               phone[1]/2 ])
 365     scale(fingerpushhole_dias)
 366     circle(r= 0.5 );
 367 }
 368
 369 module RearCameraAperture(){
 370   CaseBase_rhsflip([1])
 371     mirror([0, 0, 1])
 372     linear_extrude(height = 20)
 373     mirror([0, 1, 0])
 374     translate(bumper)
 375     rectfromto(camera_pos_tl, camera_pos_br);
 376 }
 377
 378 module CaseBase(){
 379   AroundEdges(epp3[1], case_th_bottom, 1)
 380     EdgeProfile();
 381 }
 382
 383 module Case(){ ////toplevel
 384   difference(){
 385     union(){
 386       CaseBase();
 387
 388       // ledge (fixed keeper)
 389       intersection(){
 390         rotate([90, 0, 0])
 391           linear_extrude(height = phone_height + phone_cnr_rad * 2)
 392           KeeperProfile(1);
 393
 394         // outline of the whole case, to stop it protruding
 395         translate([0,0, -25])
 396           linear_extrude(height = 50)
 397           hull()
 398           // CaseBase_rhsflip() // actually, we only care about the LH
 399           CaseBase_botflip()
 400           circleat([+1,-1] * phone_cnr_rad, phone_cnr_rad + case_th_side/2);
 401       }
 402     }
 403
 404     // slot for keeper
 405     CaseBase_rhsflip(1)
 406       translate([0, -phone_cnr_rad, 0])
 407       rotate([90, 0, 0])
 408       linear_extrude(height = phone_height + phone_cnr_rad * 2)
 409       minkowski(){
 410         KeeperProfile();
 411         rectfromto([ -keeper_gap_x,    -keeper_gap_z_bot ],
 412                    [ keeper_gap_x_holes,    +keeper_gap_z_top ]);
 413       }
 414
 415     // front camera
 416     RearCameraAperture();
 417
 418     // struts (invisible, because they're buried in the case)
 419     Struts(epp2i[0], epp2i[1] - case_th_bottom, case_th_bottom);
 420
 421     Buttons(){
 422       mirror([1,0,0])
 423         rotate([90,0,90]) {
 424           intersection(){
 425             translate([0,0,-10])
 426               linear_extrude(height= 20)
 427               ButtonPlan($button_l, 0,1);
 428             if ($button_leg_only)
 429               rotate([-90,90,0])
 430                 translate([phone_width/2, -400, kppe[1]])
 431                 mirror([$rhsflip,0,0]) cube([400, 800, 50]);
 432           }
 433           translate([0,0, -bppR[0]])
 434             linear_extrude(height= 20)
 435             ButtonPlan($button_l, 1,1);
 436         }
 437     }
 438
 439     // apertures along top edge
 440     CaseAperture(jack_pos, jack_dia, 8);
 441     CaseBase_rhsflip([1])
 442       CaseAperture(noisecancelmic_pos, noisecancelmic_dia, 20);
 443
 444     OrdinaryRearApertures();
 445   }
 446 }
 447
 448 module Lid(){ ////toplevel
 449   difference(){
 450     union(){
 451       AroundEdges(lpp10[1], lpp13[1] - lpp10[1], 0)
 452         LidEdgeProfile();
 453
 454       // button covers
 455       Buttons(){
 456         intersection(){
 457           rotate([90,0,90])
 458             translate([0,0,-10])
 459             linear_extrude(height= 20)
 460             ButtonPlan($button_l, 1,0);
 461           rotate([90,0,0])
 462              translate([0,0,-100])
 463             linear_extrude(height= 200)
 464             ButtonCoverProfile();
 465         }
 466       }
 467     }
 468     Struts(lpp10[0] + strut_min_at_end, lpp13[1], -case_th_lid);
 469   }
 470 }
 471
 472 module TestSelectLength(){
 473   translate([-30, -200, -20])
 474     cube([30 + 15, 250, 40]);
 475 }
 476
 477 module TestLength(){ ////toplevel
 478   intersection(){
 479     Case();
 480     TestSelectLength();
 481   }
 482 }
 483
 484 module TestLengthRight(){ ////toplevel
 485   intersection(){
 486     Case();
 487     CaseBase_rhsflip(1)
 488       TestSelectLength();
 489   }
 490 }
 491
 492 module TestSelectWidth(){
 493   translate([-30, -(phone_height - 25), -20])
 494     mirror([0, 1, 0])
 495     cube([200, 50, 40]);
 496 }
 497
 498 module TestWidth(){ ////toplevel
 499   intersection(){
 500     Case();
 501     TestSelectWidth();
 502   }
 503 }
 504
 505 module TestLidWidthPrint(){ ////toplevel
 506   rotate([0,180.0]) intersection(){
 507     Lid();
 508     TestSelectWidth();
 509   }
 510 }
 511
 512 module TestSelectRearAperture(){
 513   minkowski(){
 514     union() children();
 515     translate([20, 0,0])
 516       cube([42, 2, 1], center=true);
 517   }
 518 }
 519
 520 module TestSelectCamera(){
 521   minkowski(){
 522     TestSelectRearAperture()
 523       RearCameraAperture();
 524     cube([0.1, 50, 0.1]);
 525   }
 526 }
 527
 528 module TestSelectOrdinaryRearApertures(){
 529   TestSelectRearAperture()
 530     OrdinaryRearApertures();
 531 }
 532
 533 module TestCamera(){ ////toplevel
 534   intersection(){
 535     Case();
 536     TestSelectCamera();
 537   }
 538 }
 539
 540 module TestLidByCamera(){ ////toplevel
 541   intersection(){
 542     Lid();
 543     TestSelectCamera();
 544   }
 545 }
 546
 547 module TestLidByCameraPrint(){ ////toplevel
 548   rotate([180,0,0]) TestLidByCamera();
 549 }
 550
 551 module DemoByCamera(){ ////toplevel
 552   color("blue") TestLidByCamera();
 553   color("red")  TestCamera();
 554 }
 555
 556 module OneKeeper(){ ////toplevel
 557   translate([0, -phone_cnr_rad, 0])
 558     rotate([90, 0, 0])
 559     linear_extrude(height = phone_height - phone_cnr_rad * 2)
 560     KeeperProfile();
 561 }
 562
 563 module OneKeeperPrint(){ ////toplevel
 564   rotate([0,180,0])
 565     OneKeeper();
 566 }
 567
 568 module LidPrint(){ ////toplevel
 569   rotate([0,180,0])
 570     Lid();
 571 }
 572
 573 module TestSelectFrame(){
 574   include = [1,-1] * (epp2i[0] + 4);
 575
 576   difference(){
 577     cube(1000, center=true);
 578     translate([0,0, -100])
 579       linear_extrude(height=200)
 580       rectfromto(include,  inside_br - include);
 581   }
 582 }
 583
 584 module TestFrameCase(){ ////toplevel
 585   intersection(){
 586     Case();
 587     union(){
 588       TestSelectFrame();
 589       TestSelectCamera();
 590       TestSelectOrdinaryRearApertures();
 591     }
 592   }
 593 }
 594
 595 module TestFrameLidPrint(){ ////toplevel
 596   rotate([0,0,180]) intersection(){
 597     Lid();
 598     TestSelectFrame();
 599   }
 600 }
 601
 602 module Keeper(){ ////toplevel
 603   CaseBase_rhsflip()
 604     OneKeeper();
 605 }
 606
 607 module ButtonPlanForDemo(z, deep, cut){
 608   translate([0,0,z])
 609     ButtonPlan(8, deep, cut);
 610 }
 611
 612 module DemoProfiles(){ ////toplevel
 613   LidEdgeProfile();
 614   %EdgeProfile();
 615   KeeperProfile();
 616   translate([0,0,-1]) color("black") KeeperProfile(1);
 617
 618   translate([20,0]) {
 619     LidEdgeProfile();
 620     %EdgeProfile();
 621
 622     demopoint_QR = [ bppS[0], bppQ[1] - 0.1];
 623
 624     color("blue") ButtonCoverProfile();
 625     color("red") {
 626       rectfromto(bppQ, demopoint_QR);
 627       rectfromto(bppR, demopoint_QR);
 628     }
 629   }
 630
 631   translate([-20,0]) {
 632     color("black") ButtonPlanForDemo(-2, 0,1);
 633     color("red" )  ButtonPlanForDemo(-4, 1,1);
 634     color("blue")  ButtonPlanForDemo(-6, 1,0);
 635   }
 636 }
 637
 638 //EdgeProfile();
 639 //KeeperProfile();
 640 //CaseBase();
 641 //%Case();
 642 //Keeper();
 643 //LidEdgeProfile();
 644 //KeeperProfile();
 645 //DemoProfiles();