path: root/enclosure/enclosure.scad

/*
  a box divided on layers, 4 long screws at the corners to keep it
  together, alignment pins between layers
 
  * top, big hole for the screen and small holes for air
 
  * board, holds the board and the switch / button / usb / sd holes on
    the sides; the co2 sensor probably goes here as well
 
  * bottom, for battery and pm sensor
 */
 
WALL_THICKNESS=1;
 
SCREW_DIAM=4;
SCREW_PAD=0;
 
PM_X=40.8;
PM_Y=40.8;
PM_Z=12.5;
PM_CONN_Y=15.8;
PM_CONN_Z=4;
PM_CONN_DEPTH=7.7;
 
BATT_X=55;
BATT_Y=33.5;
BATT_Z=10.8;
 
CO_X=28.5;
CO_Y=24.1;
CO_Z=8;
CO_CONN_Y=10;
 
CO_HOLE_DIAM=2;
CO_HOLE_DIST=CO_HOLE_DIAM + 2; // distance between hole centres
 
BOT_CABLE_WELL_X=15; // just some space for the battery & pm cables
MID_CABLE_WELL_X=5;  // just some space between co2 & board
 
BOTTOM_Z=WALL_THICKNESS + PM_Z;
MIDDLE_Z=WALL_THICKNESS + CO_Z;
 
DISPLAY_WIN_X=51;
DISPLAY_WIN_Y=26;
DISPLAY_X_OFF=2.5;
DISPLAY_Y_OFF=6.1;
 
//PITCH=0.254; don't really care
BOARD_X=66.5;
BOARD_Y=36.8;
BOARD_SINK=2.2;
BOARD_PAD=0;
 
BOARD_PIN_OFF_X=2.35; BOARD_PIN_DIST_X=61.43;
BOARD_PIN_OFF_Y=2.15; BOARD_PIN_DIST_Y=32.5;
 
BOARD_SUPPORT_DIAM=3;
BOARD_SUPPORT_PIN_DIAM=2;
 
USB_MICRO_B_X=12;
USB_MICRO_B_Z=5.5;
 
USB_MICRO_B_SINK=2;
USB_MICRO_B_OFF_X=42.7;
 
SD_X=12.5;
SD_Y=9.5;
SD_Z=1;
SD_SINK=3;
SD_OFF_X=54;
 
SWITCH_X=9;
SWITCH_Y=2;
SWITCH_Z=4;
SWITCH_SINK=SWITCH_Z/2;
SWITCH_OFF_X=42.5;
 
RESET_X=2.5;
RESET_Z=2;
RESET_SINK=1;
RESET_OFF_X=51;
 
BUTTON_X=5;
BUTTON_Z=3;
BUTTON_SINK=1;
BUTTON_OFF_X=58;
 
TOP_Z=2;
 
PILLAR_Y=WALL_THICKNESS*2;
PILLAR_SHRINK=0.05;
 
TOTAL_X=2*WALL_THICKNESS + max(
                               PM_X + BOT_CABLE_WELL_X + BATT_X,
                               CO_X + MID_CABLE_WELL_X + BOARD_X
                               );
TOTAL_Y=2*(WALL_THICKNESS + SCREW_DIAM + SCREW_PAD) + max(PM_Y,CO_Y,BOARD_Y,BATT_Y);
 
module box(v) {
  translate([0,0,v[2]/2]) cube(v,center=true);
}
 
module screw_hole() {
  cylinder(h=200,d=SCREW_DIAM,center=true,$fs=0.1);
}
 
module screw_holes() {
  OFF=WALL_THICKNESS + SCREW_DIAM/2 + SCREW_PAD;
 
  translate([
             TOTAL_X/2 - OFF,
             TOTAL_Y/2 - OFF,
             0]) screw_hole();
 
  translate([
             -(TOTAL_X/2 - OFF),
             TOTAL_Y/2 - OFF,
             0]) screw_hole();
 
  translate([
             TOTAL_X/2 - OFF,
             -(TOTAL_Y/2 - OFF),
             0]) screw_hole();
 
  translate([
             -(TOTAL_X/2 - OFF),
             -(TOTAL_Y/2 - OFF),
             0]) screw_hole();
             
}
 
module pm_sensor() {
  box([PM_X,PM_Y,PM_Z]);
}
 
module bottom_cable_well() {
  box([BOT_CABLE_WELL_X,PM_CONN_Y,PM_CONN_DEPTH]);
}
 
module battery() {
  box([BATT_X,BATT_Y,BATT_Z]);
}
 
module co_sensor() {
  box([CO_X,CO_Y,CO_Z]);
}
 
module co_hole() {
  cylinder(h=200,d=CO_HOLE_DIAM,center=true,$fs=0.2);
}
 
module co_holes() {
  translate([-CO_X/2,-CO_Y/2,0])
    for(
        x=[CO_HOLE_DIAM:CO_HOLE_DIST:CO_X],
          y=[CO_HOLE_DIAM:CO_HOLE_DIST:CO_Y]
        )
      translate([x,y,0]) co_hole();
}
 
module middle_cable_well() {
  box([
       20, // doesn't matter, wells at both sides are much wider
       CO_CONN_Y,
       CO_Z,
        ]);
}
 
module board_well() {
  cube([ BOARD_X+BOARD_PAD, BOARD_Y+BOARD_PAD, 200], center=true);
}
 
module board_support() {
  HEIGHT=MIDDLE_Z - BOARD_SINK;
  EXTRA=BOARD_SUPPORT_DIAM*2;
 
  translate([0,0,HEIGHT/2]) union() {
    cylinder(
             h=HEIGHT,
             d=BOARD_SUPPORT_DIAM,
             center=true,$fs=0.1
             );
 
    translate([EXTRA/2, EXTRA/2 - BOARD_SUPPORT_DIAM/2, 0])
      cube([EXTRA,EXTRA,HEIGHT],center=true);
    translate([EXTRA/2 - BOARD_SUPPORT_DIAM/2, EXTRA/2, 0])
      cube([EXTRA,EXTRA,HEIGHT],center=true);
 
    translate([0,0,BOARD_SINK/2]) cylinder(
             h=HEIGHT+BOARD_SINK,
             d=BOARD_SUPPORT_PIN_DIAM,
             center=true,$fs=0.1
             );
  }
}
 
module board_supports() {
  translate([ -BOARD_X/2 + BOARD_PIN_OFF_X, -BOARD_Y/2 + BOARD_PIN_OFF_Y,0]) {
    translate([ 0, 0, 0]) rotate([0,0,180]) board_support();
    translate([ BOARD_PIN_DIST_X, 0, 0]) rotate([0,0,-90]) board_support();
    translate([ 0, BOARD_PIN_DIST_Y, 0]) rotate([0,0,90]) board_support();
    translate([ BOARD_PIN_DIST_X, BOARD_PIN_DIST_Y, 0]) board_support();
  }
}
 
module usb_well() {
  translate([0,0,-USB_MICRO_B_SINK-USB_MICRO_B_Z/2]) box([USB_MICRO_B_X, 30, 30]);
}
 
module sd_well() {
  EXTRA=10;
  translate([0,SD_Y/2-EXTRA/2,-SD_SINK-SD_Z/2]) box([SD_X, SD_Y+EXTRA, 30]);
}
 
module switch_well() {
  translate([0,0,-SWITCH_SINK-SWITCH_Z/2]) box([SWITCH_X, 30, 30]);
}
 
module switch_pillar() {
  H=BOARD_SINK+TOP_Z/2;
  translate([0,0,-H/2])
    cube([SWITCH_X-PILLAR_SHRINK, PILLAR_Y, H], center=true);
}
 
module reset_well() {
  translate([0,0,-RESET_SINK-RESET_Z/2]) box([RESET_X, 30, 30]);
}
 
module reset_pillar() {
  H=BOARD_SINK+TOP_Z/2;
  translate([0,0,-H/2])
    cube([RESET_X-PILLAR_SHRINK, PILLAR_Y, H], center=true);
}
 
module button_well() {
  translate([0,0,-BUTTON_SINK-BUTTON_Z/2]) box([BUTTON_X, 30, 30]);
}
 
module button_pillar() {
  H=BOARD_SINK+TOP_Z/2;
  translate([0,0,-H/2])
    cube([BUTTON_X-PILLAR_SHRINK, PILLAR_Y, H], center=true);
}
 
// these will have matching pillars for the top piece, filling them
// down to the right depth; top piece will be printed upside-down
module outside_wells() {
  translate([-BOARD_X/2,0,0]) {
    translate([0,BOARD_Y/2,0]) {
        translate([USB_MICRO_B_OFF_X, 0,0]) usb_well();
        translate([SD_OFF_X, 0,0]) sd_well(); // not actually facing outside
    };
    translate([0,-BOARD_Y/2,0]) {
        translate([SWITCH_OFF_X, 0,0]) switch_well();
        translate([RESET_OFF_X, 0,0]) reset_well();
        translate([BUTTON_OFF_X, 0,0]) button_well();
    };
  }
}
 
module outside_pillars() {
  translate([-BOARD_X/2,0,TOP_Z/2]) {
    translate([0,-TOTAL_Y/2+PILLAR_Y/2,0]) {
        translate([SWITCH_OFF_X, 0,0]) switch_pillar();
        translate([RESET_OFF_X, 0,0]) reset_pillar();
        translate([BUTTON_OFF_X, 0,0]) button_pillar();
    };
  }
}
 
module display_hole() {
  cube([DISPLAY_WIN_X, DISPLAY_WIN_Y, 30], center=true);
}
 
module bottom() {
  PM_X_OFF=(TOTAL_X - PM_X)/2;
 
  CABLE_X_OFF= PM_X_OFF - PM_X/2 - BOT_CABLE_WELL_X/2; // touching the PM pocket
  CABLE_Y_OFF=-PM_Y/2 + PM_CONN_Y/2;
  CABLE_Z_OFF=BOTTOM_Z - PM_CONN_DEPTH;
 
  BATT_X_OFF=CABLE_X_OFF - BOT_CABLE_WELL_X/2 - BATT_X/2;
  BATT_Z_OFF=BOTTOM_Z - BATT_Z;
 
  difference() {
    box([TOTAL_X, TOTAL_Y, BOTTOM_Z]);
    screw_holes();
    translate([PM_X_OFF, 0, WALL_THICKNESS]) pm_sensor();
    translate([CABLE_X_OFF, CABLE_Y_OFF, CABLE_Z_OFF]) bottom_cable_well();
    translate([BATT_X_OFF, 0, BATT_Z_OFF]) battery();
  }
}
 
// used by middle and top
BOARD_X_OFF= (TOTAL_X-BOARD_X)/2 - CO_X - MID_CABLE_WELL_X - WALL_THICKNESS;
BOARD_Y_OFF= (-TOTAL_Y+BOARD_Y)/2 + SWITCH_Y;
CO_X_OFF=(TOTAL_X - CO_X)/2 - WALL_THICKNESS;
 
module middle() {
  CO_Z_OFF=MIDDLE_Z - CO_Z;
 
  CABLE_X_OFF= CO_X_OFF - CO_X/2 - MID_CABLE_WELL_X/2;
 
  BOARD_Z_OFF=MIDDLE_Z - BOARD_SINK;
 
  union() {
    difference() {
      box([TOTAL_X, TOTAL_Y, MIDDLE_Z]);
      screw_holes();
      translate([CO_X_OFF, 0, CO_Z_OFF]) co_sensor();
      translate([CABLE_X_OFF, 0, CO_Z_OFF]) middle_cable_well();
      translate([BOARD_X_OFF, BOARD_Y_OFF, 0]) {
        translate([0,0, 0]) board_well();
        translate([0,0, BOARD_Z_OFF]) outside_wells();
      }
    }
    intersection() {
      translate([BOARD_X_OFF, BOARD_Y_OFF, 0]) board_supports();
      box([TOTAL_X, TOTAL_Y, MIDDLE_Z]);
    }
  }
}
 
module top() {
  DISP_X_OFF=BOARD_X_OFF - (BOARD_X-DISPLAY_WIN_X)/2 + DISPLAY_X_OFF;
  DISP_Y_OFF=BOARD_Y_OFF - (BOARD_Y-DISPLAY_WIN_Y)/2 + DISPLAY_Y_OFF;
 
  union() {
    difference() {
      box([TOTAL_X, TOTAL_Y, TOP_Z]);
      screw_holes();
      translate([CO_X_OFF, 0, 0]) co_holes();
      translate([DISP_X_OFF, DISP_Y_OFF, 0]) display_hole();
    }
    translate([BOARD_X_OFF, 0, 0])
      outside_pillars();
  }
}
 
//translate([0, TOTAL_Y * 1.2, 0]) bottom();
//translate([0, 0, -BOTTOM_Z-2]) bottom();
 
middle();
 
//translate([0, -TOTAL_Y * 1.2, 0]) rotate([180,0,0]) top();
//translate([0, 0, +MIDDLE_Z+2]) top();