mini-itx2.openscad

mb = [170.3, 170.3, 2];
case_thick = 2;

iopanel = [-2, -2, -2];
iopanel_width = 159;
iopanel_height = 45;

pcie_back_width = 20;
pcie_back_bottom_width = 12;
pcie_back_offset = 0;
pcie_back_depth = 9; // below the surface of MB
pcie_back_height = 80;

back_space = 5;

fan = [12, 38, 40];
fan_size = 98;
duct_bottom = 47;

mb_holder1_depth = 31;
block_size = 5;

mb_bottom_space = pcie_back_depth - mb.z - (case_thick - 1); // bottom of pcie penetrates the floor by 2mm
mb_left_space = -iopanel.x + block_size;
mb_right_space = pcie_back_width / 2 + case_thick * 2;
ceiling = 1 + pcie_back_height - case_thick - mb_bottom_space;

power_panel = [fan.x + fan_size + case_thick, -back_space - case_thick, duct_bottom];
power_panel_width = mb.x - pcie_back_width / 2 - power_panel.x;
power_panel_height = ceiling - power_panel.z;

outer_space = 200;

case = [case_thick * 2 + + mb_left_space + mb.x + mb_right_space, case_thick * 2 + back_space + mb.y, case_thick * 2 + mb_bottom_space + ceiling];

// bottom
if (1) {
    difference () {
        outer_cube();
        // large cut
        translate([-outer_space, -back_space, -mb_bottom_space])
            cube([outer_space * 2, outer_space * 2, outer_space]);
        // cut top
        translate([-outer_space, -outer_space, duct_bottom])
            cube([outer_space * 2, outer_space, outer_space]);
        // cut sides
        translate([-case_thick - mb_left_space, -outer_space, -outer_space])
            cube([case_thick, outer_space * 2, outer_space * 2]);
        translate([mb.x + mb_right_space, -outer_space, -outer_space])
            cube([case_thick, outer_space * 2, outer_space * 2]);
        // cut front
        translate([-outer_space, mb.y, -outer_space])
            cube([outer_space * 2, outer_space * 2, outer_space * 2]);
        // cut bottom
        translate([block_size, mb_holder1_depth + block_size * 2, -outer_space])
            cube([mb.x - block_size * 2, outer_space, outer_space]);

        // io panel
        translate([iopanel.x, -outer_space, iopanel.z])
            cube([iopanel_width, outer_space, iopanel_height]);

        // pcie back panel
        translate([mb.x - pcie_back_width / 2, -back_space - case_thick, -mb_bottom_space])
            cube([pcie_back_width, case_thick, outer_space]);
        translate([mb.x - pcie_back_bottom_width / 2, -outer_space, -outer_space])
            cube([pcie_back_bottom_width, outer_space - pcie_back_offset, outer_space * 2]);

        // power unit
        translate([power_panel.x, -outer_space, power_panel.z])
            cube([power_panel_width, outer_space, power_panel_height]);
    }

    // reinforce bottom
    union () {
        translate([-mb_left_space, -back_space, -mb_bottom_space])
            cube([block_size, back_space + mb.y, case_thick]);
        translate([mb.x + mb_right_space - block_size, -back_space, -mb_bottom_space])
            cube([block_size, back_space + mb.y, case_thick]);
    }

    // reinforce back panel
    union () {
        d = 20;
        translate([-mb_left_space, -back_space, -mb_bottom_space])
            cube([case_thick, d, mb_bottom_space + duct_bottom]);
        translate([-mb_left_space, -back_space, duct_bottom - case_thick])
            cube([mb_left_space + mb.x - pcie_back_width, d, case_thick]);
        translate([mb.x + mb_right_space - case_thick, -mb_bottom_space, -mb_bottom_space])
            cube([case_thick, d, mb_bottom_space + duct_bottom]);
    }

    // mb holder 1
    translate([0, mb_holder1_depth, -mb_bottom_space])
        cube_with_holder(block_size, block_size, mb_bottom_space, 0);
    translate([-block_size, mb_holder1_depth - block_size, -mb_bottom_space])
        cube_with_holder(block_size, block_size * 2, mb_bottom_space + mb.z + block_size, 0);
    translate([0, mb_holder1_depth, mb.z])
        cube_with_holder(block_size, block_size, block_size, 1);

    // mb holder 2
    translate([0, mb.y - block_size, -mb_bottom_space])
        cube_with_holder(block_size, block_size, mb_bottom_space, 0);

    // mb holder 3
    difference () {
        translate([mb.x - block_size, 0, -mb_bottom_space])
            cube([block_size * 2, block_size, mb_bottom_space + mb.z + 3]);
        translate([mb.x - block_size, 0, 0])
            cube([block_size, block_size, mb.z]);
    }

    // mb holder 4
    translate([mb.x - block_size, mb.y - block_size, -mb_bottom_space])
        cube_with_holder(block_size, block_size, mb_bottom_space, 0);
}

// top
if (1) {
    translate([-30, 0, 50]) rotate([0, 180, 0]) {
        // top and side panels
        difference () {
            outer_cube();
            // cut back panel
            translate([-mb_left_space, -outer_space, -outer_space])
                cube([mb_left_space + mb.x + mb_right_space, outer_space - back_space, outer_space + ceiling]);
            // floor panel
            translate([-mb_left_space, -outer_space, -outer_space])
                cube([mb_left_space + mb.x + mb_right_space, outer_space + mb.y, outer_space - mb_bottom_space]);
            // holes in side panel
            translate([mb.x - 100, 20, -mb_bottom_space / 2])
                rotate([90, 0, 90])
                    punch_honeycomb(8, 5, 200);
        }

        // mb holder 2
        translate([0, mb.y - block_size, mb.z])
            cube_with_holder(block_size, block_size, block_size, 2);

        // mb holder 4
        translate([mb.x - block_size, mb.y - block_size, mb.z])
            cube_with_holder(block_size, block_size, block_size, 2);

        // pcie back panel
        translate([mb.x + pcie_back_width / 2, -case_thick - back_space, -mb_bottom_space])
            cube([mb_right_space - pcie_back_width / 2, case_thick, mb_bottom_space + ceiling]);

        // duct
        difference () {
            union () {
                translate([fan.x - case_thick, fan.y - case_thick, fan.z])
                    cube([fan_size + case_thick * 2, fan_size + case_thick * 2, ceiling - fan.z]);
                outer_duct();
            }
            translate([fan.x, fan.y, fan.z])
                cube([fan_size, fan_size, ceiling - fan.z]);
            translate([-mb_left_space, -outer_space, duct_bottom + case_thick])
                cube([mb_left_space + fan.x + fan_size, outer_space + fan.y + fan_size, ceiling - duct_bottom - case_thick]);
            translate([-outer_space, fan.y, duct_bottom + case_thick])
                cube([outer_space + fan.x, fan_size, ceiling - duct_bottom - case_thick]);
        }

        power_panel_top_latch();
    }
}


module outer_cube() {
    difference () {
        translate([-(mb_left_space + case_thick), -(back_space + case_thick), -(case_thick + mb_bottom_space)]) {
            difference () {
                translate([0, case.y, 0])
                    rotate([90, 0, 0])
                        linear_extrude(height = case.y)
                            round_rect(case.x, case.z, case_thick);
                translate([case_thick, case_thick, case_thick])
                    cube([case.x - case_thick * 2, case.y - case_thick * 2, case.z - case_thick * 2]);
            }
        }
        outer_duct();
    }
}

module outer_duct() {
    y = -back_space - case_thick;
    depth = fan.y + fan_size + case_thick;
    translate([-mb_left_space, y, duct_bottom])
        cube([mb_left_space + fan.x + fan_size + case_thick, depth - y, ceiling - duct_bottom]);
    translate([-case_thick - mb_left_space, y + case_thick, duct_bottom])
        cube([case_thick + mb_left_space + fan.x, depth - y - case_thick, ceiling - duct_bottom]);
}

module power_panel_top_latch() {
    translate([power_panel.x + 10, 0, ceiling - case_thick])
        cube([power_panel_width - 10, case_thick * 2, case_thick]);
}

module round_rect(w, d, r) {
    union () {
        translate([0, r])
            square([w, d - r * 2]);
        translate([r, 0])
            square([w - r * 2, d]);
        translate([r, r])
            circle(r, $fn = 32);
        translate([w - r, r])
            circle(r, $fn = 32);
        translate([r, d - r])
            circle(r, $fn = 32);
        translate([w - r, d - r])
            circle(r, $fn = 32);
    }
}

module cube_with_holder(w, d, h, holder_side) {
    cube([w, d, h]);
    if (holder_side == 0) {
        rotate([0, -90, 180])
            linear_extrude(height = w)
                polygon(points = [[0, 0], [0, h], [h, 0]]);
    } else if (holder_side == 1) {
        translate([0, -w, 0])
                linear_extrude(height = h)
                    polygon(points = [[0, 0], [w, w], [0, w]]);
    } else if (holder_side == 2) {
        translate([w, -h, 0])
            rotate([0, -90, 0])
                linear_extrude(height = w)
                    polygon(points = [[0, h], [h, h], [h, 0]]);
    }
}

module punch_honeycomb(w, d, h) {
    hex_size = 10;
    for (x = [0 : w - 1]) {
        for (y = [0 : d - 1]) {
            translate([x * hex_size * sqrt(3), hex_size + y * hex_size, 0])
                cylinder(h = h, r = hex_size * 0.45, $fn = 6);
            translate([(x * 2 + 1) * hex_size / 2 * sqrt(3), 1.5 * hex_size + y * hex_size, 0])
                cylinder(h = h, r = hex_size * 0.45, $fn  = 6);
        }
    }
}