External hard drive monitor mount

// Hard drive mount / bracket
// Mounts onto a rectangular post (62x37mm) and holds a vertical 2.5" hard drive / SSD

/* [Mount Post Socket (Base)] */
// Inside width of socket (X)
socket_inner_w = 62; // [40:0.5:100]
// Inside depth of socket (Y)
socket_inner_d = 40; // [20:0.5:80]
// Inside height of socket (Z)
socket_inner_h = 90; // [50:1:150]
// Socket wall thickness
socket_wall = 2; // [1.2:0.2:5.0]

/* [HDD Slot] */
// HDD slot inner width (X)
hdd_inner_w = 111; // [80:0.5:150]
// HDD slot inner thickness (Y) - 7.5mm drive thickness
hdd_inner_t = 16; // [10.0:0.5:20.0]
// HDD slot height (Z)
hdd_slot_h = 35; // [15:1:60]
// HDD wall thickness
hdd_wall = 2; // [1:0.2:5.0]
// HDD bottom floor thickness
hdd_bottom_t = 2; // [1.0:0.2:5.0]
// Inset of HDD pocket into the main post body (Y) - must always equal hdd_wall
hdd_inset_y = hdd_wall;

/* [Ventilation Slots] */
// Width of ventilation slots (along X or Y)
vent_slot_w = 4.0; // [2:0.5:10]
// Spacing between ventilation slots
vent_slot_spacing = 8.0; // [4:0.5:20]
// Margin from the inner walls for slots
vent_margin_x = 10.0; // [5:1:30]
// Slot corner radius
vent_slot_r = 1.5; // [0:0.5:4]

/* [Reinforcement Fillets] */
// Fillet radius connecting socket side to HDD back wall
fillet_radius = 7; // [5:1:25]

/* [Detail & Printability] */
// Outer corner fillet radius
corner_r = 2.0; // [0:0.5:5]
// Cutout bottom width
cutout_bottom_w = 48;
// Cutout chamfer delta X
cutout_chamfer_dx = 10;
// Cutout bottom Z
cutout_bottom_z = 10;

$fn = 120;

// Calculated outer dimensions
sock_outer_w = socket_inner_w + 2 * socket_wall; // 66mm
sock_outer_d = socket_inner_d + 2 * socket_wall; // 41mm
sock_outer_h = socket_inner_h + socket_wall; // closed on top, open at bottom

hdd_outer_w = hdd_inner_w + 2 * hdd_wall; // 114mm
hdd_outer_d = hdd_inner_t + 2 * hdd_wall; // 11.5mm
hdd_outer_h = hdd_slot_h; // 30mm

// Y position of HDD pocket front/back reference
// The HDD pocket starts at sock_outer_d - hdd_inset_y
hdd_y_pos = sock_outer_d - hdd_inset_y; // 39mm

module rounded_box(size, r) {
    if (r <= 0) {
        cube(size);
    } else {
        hull() {
            for (x = [r, size[0] - r]) {
                for (y = [r, size[1] - r]) {
                    translate([x, y, 0])
                        cylinder(r = r, h = size[2]);
                }
            }
        }
    }
}

// 2D fillet region at the external corner between socket side (X = +sock_outer_w/2)
// and HDD rear wing (Y = hdd_y_pos, extending to X = +hdd_outer_w/2).
// In the user's bottom view:
// The socket side wall runs along Y at X = sock_outer_w/2.
// The HDD back wall runs along X at Y = hdd_y_pos.
// The fillet connects the socket side wall to the HDD back wall with an arc of radius R.
// The arc center is at (px + r, py - r).
// Point on socket wall: (px, py - r).
// Point on HDD back wall: (px + r, py).
// It fills ONLY the corner outside the two bodies, extending slightly inside them (-overlap)
// so union is clean, but NEVER extending past Y = hdd_y_pos.
module corner_fillet_2d(px, py, r) {
    ov = 1.0; // overlap into socket and pocket
    n_steps = 180; // ultra-smooth curve
    polygon(points = concat(
        [[px - ov, py], [px - ov, py - r - ov], [px, py - r - ov]],
        [for (i = [0 : n_steps]) let(a = 90 * i / n_steps) [px + r - r * cos(a), py - r + r * sin(a)]],
        [[px + r, py]]
    ));
}

module corner_reinforcement(mirror_x = false) {
    m = mirror_x ? -1 : 1;
    px = sock_outer_w / 2;
    py = hdd_y_pos;
    r = fillet_radius;

    scale([m, 1, 1]) {
        // Vertical prismatic section matching the full height of the HDD pocket
        translate([0, 0, 0])
        linear_extrude(height = hdd_outer_h) {
            corner_fillet_2d(px, py, r);
        }
    }
}

module front_cutout_profile() {
    xb = cutout_bottom_w / 2;
    xt = cutout_bottom_w / 2 + cutout_chamfer_dx;
    zb = cutout_bottom_z;
    zt = hdd_outer_h;
    r = corner_r;

    if (r <= 0.05) {
        polygon(points = [
            [-xt, zt + 5],
            [-xt, zt],
            [-xb, zb],
            [xb, zb],
            [xt, zt],
            [xt, zt + 5]
        ]);
    } else {
        dx = xt - xb;
        dz = zt - zb;
        len_diag = sqrt(dx * dx + dz * dz);
        k = (len_diag - dx) / dz;

        // Bottom fillet center
        cbx = xb - r * k;
        cbz = zb + r;

        // Top fillet center
        ctx = xt + r * k;
        ctz = zt - r;

        n_arc = 30;
        a_bot_end = atan2(-dx, dz);
        a_top_start = 180 - atan2(dx, dz);

        // Bottom arc: from -90 deg up to slope tangency
        right_bot_arc = [
            for (i = [0 : n_arc])
                let(a = -90 + (a_bot_end - (-90)) * i / n_arc)
                [cbx + r * cos(a), cbz + r * sin(a)]
        ];

        // Top arc: from slope tangency down to 90 deg (horizontal rim)
        right_top_arc = [
            for (i = [0 : n_arc])
                let(a = a_top_start + (90 - a_top_start) * i / n_arc)
                [ctx + r * cos(a), ctz + r * sin(a)]
        ];

        right_pts = concat(
            [[0, zb]],
            right_bot_arc,
            right_top_arc,
            [[ctx, zt + 5]]
        );

        // Mirror for left side (reverse order, negate x)
        num_r = len(right_pts);
        left_pts = [
            for (i = [num_r - 1 : -1 : 1])
                [-right_pts[i][0], right_pts[i][1]]
        ];

        polygon(points = concat(left_pts, right_pts));
    }
}

// Ventilation slot in 2D
module rounded_slot_2d(w, l, r) {
    if (r <= 0) {
        square([w, l], center = true);
    } else {
        r_eff = min(r, min(w, l) / 2);
        offset(r = r_eff) offset(delta = -r_eff)
            square([w, l], center = true);
    }
}

// Ventilation slots cutout on the HDD pocket bottom floor
module hdd_vent_slots() {
    usable_w = hdd_inner_w - 2 * vent_margin_x;
    slot_len = max(2, hdd_inner_t - 4);
    n_slots = floor(usable_w / vent_slot_spacing);
    
    if (n_slots > 0) {
        start_x = -((n_slots - 1) * vent_slot_spacing) / 2;
        center_y = hdd_y_pos + hdd_wall + hdd_inner_t / 2;
        
        for (i = [0 : n_slots - 1]) {
            x = start_x + i * vent_slot_spacing;
            translate([x, center_y, -1])
                linear_extrude(height = hdd_bottom_t + 2)
                    rounded_slot_2d(vent_slot_w, slot_len, vent_slot_r);
        }
    }
}

// @name HDD Mount
module hdd_post_mount() {
    difference() {
        // Outer fused solid
        union() {
            // Post socket outer body
            translate([-sock_outer_w / 2, 0, 0])
                rounded_box([sock_outer_w, sock_outer_d, sock_outer_h], corner_r);
            
            // HDD pocket outer body
            translate([-hdd_outer_w / 2, hdd_y_pos, 0])
                rounded_box([hdd_outer_w, hdd_outer_d, hdd_outer_h], corner_r);

            // Right & Left reinforcements
            corner_reinforcement(false);
            corner_reinforcement(true);
        }

        // Post socket internal bore (open at bottom, exactly 62x37mm, height 90mm)
        translate([-socket_inner_w / 2, socket_wall, -1])
            cube([socket_inner_w, socket_inner_d, socket_inner_h + 1]);

        // HDD pocket cavity (open at top, exactly 110x7.5mm, height 30mm)
        translate([-hdd_inner_w / 2, hdd_y_pos + hdd_wall, hdd_bottom_t])
            cube([hdd_inner_w, hdd_inner_t, hdd_outer_h - hdd_bottom_t + 1]);

        // Ventilation slots in HDD floor
        hdd_vent_slots();
            
        // Front grip cutout with smoothly rounded top and bottom corners
        translate([0, hdd_y_pos + hdd_outer_d + 1, 0]) {
            rotate([90, 0, 0])
            linear_extrude(height = hdd_wall + 3) {
                front_cutout_profile();
            }
        }
    }
}

// Render the model
// @name HDD Mount
hdd_post_mount();