// Sheet-metal electronics tray -- 1 mm aluminium, 4 walls folded up 90 deg.
// Dimensions are OUTSIDE (mold-line) dimensions. Units mm, Z up, part rests on Z=0.
// mode = "folded" -> 3D part ; mode = "flat" -> 2D flat pattern (export DXF).

/* [Mode] */
mode = "folded"; // [folded, flat]

/* [Tray] */
// Outside base length (X)
length = 120; // [40:1:300]
// Outside base width (Y)
width = 80; // [30:1:300]
// Outside wall height (Z)
wall_height = 20; // [5:0.5:80]

/* [Sheet metal] */
// Sheet thickness
thickness = 1; // [0.5:0.1:3]
// Inside bend radius
bend_radius = 1; // [0.2:0.1:6]
// K-factor (neutral axis position)
k_factor = 0.44; // [0.2:0.01:0.5]
// Round corner relief diameter (centred on bend-zone corner)
relief_d = 3; // [1:0.1:10]

/* [Mounting holes] */
hole_d = 3.2; // [2:0.1:8]
hole_spacing_x = 100; // [10:1:280]
hole_spacing_y = 60; // [10:1:280]

/* [Hidden] */
T = thickness;
R = bend_radius;
K = k_factor;
a = length / 2 - (R + T);      // half-length of flat base region
b = width / 2 - (R + T);       // half-width of flat base region
BA = (PI / 2) * (R + K * T);   // bend allowance for 90 deg
fl = wall_height - (R + T);    // straight flange length
rr = relief_d / 2;
seg = 24;                      // relief slices per bend
$fn = 64;

hole_pos = [for (sx = [-1, 1], sy = [-1, 1]) [sx * hole_spacing_x / 2, sy * hole_spacing_y / 2]];
relief_pos = [for (sx = [-1, 1], sy = [-1, 1]) [sx * a, sy * b]];

// ---------- flat pattern ----------
module flat_pattern() {
    difference() {
        union() {
            square([2 * a, 2 * b], center = true);
            square([2 * (a + BA + fl), 2 * b], center = true);
            square([2 * a, 2 * (b + BA + fl)], center = true);
        }
        for (p = hole_pos) translate(p) circle(d = hole_d);
        for (p = relief_pos) translate(p) circle(r = rr);
    }
}

// ---------- folded part ----------
// One 90 deg bend in local frame: bend line at local x = ax, running along local y in [-hw, hw].
// Relief circles of radius rr sit at (ax, +-hw); they remove a strip of the bend near each end
// whose width depends on neutral-axis arc length s: y_cut(s) = hw - sqrt(rr^2 - s^2).
module annulus_sector(r0, r1, a0, a1) {
    n = 16;
    polygon(concat(
        [for (i = [0:n]) let(t = a0 + (a1 - a0) * i / n) r1 * [cos(t), sin(t)]],
        [for (i = [n:-1:0]) let(t = a0 + (a1 - a0) * i / n) r0 * [cos(t), sin(t)]]));
}

module bend(ax, hw) {
    rn = R + K * T;
    translate([ax, 0, R + T]) rotate([90, 0, 0])
    difference() {
        linear_extrude(height = 2 * hw, center = true) annulus_sector(R, R + T, -90, 0);
        // relief cuts, sliced along the arc
        for (i = [0:seg - 1]) {
            s0 = min(rr, BA) * i / seg;
            s1 = min(rr, BA) * (i + 1) / seg;
            // most aggressive cut over the slice (at s0) so the slice is fully cleared
            yc = hw - sqrt(max(rr * rr - s0 * s0, 0));
            t0 = -90 + s0 / rn * 180 / PI;
            t1 = -90 + s1 / rn * 180 / PI;
            for (sg = [-1, 1])
                translate([0, 0, sg > 0 ? yc : -hw - 1]) // after rotate: 2D-y -> Z, extrude axis -> -Y
                    linear_extrude(height = hw - yc + 1)
                        annulus_sector(R - 0.01, R + T + 0.01, t0, t1);
        }
    }
}

module side(ax, hw) {
    bend(ax, hw);
    translate([ax + R, -hw, R + T]) cube([T, 2 * hw, fl]);
}

module folded() {
    difference() {
        translate([-a, -b, 0]) cube([2 * a, 2 * b, T]);
        for (p = hole_pos) translate([p[0], p[1], -1]) cylinder(d = hole_d, h = T + 2);
        for (p = relief_pos) translate([p[0], p[1], -1]) cylinder(r = rr, h = T + 2);
    }
    side(a, b);
    rotate(180) side(a, b);
    rotate(90) side(b, a);
    rotate(-90) side(b, a);
}

if (mode == "flat") flat_pattern();
else if (mode == "folded") folded();