// Modular Single Board Computer mount for server rack
// length units are millimeters
rackFunctionalWidth = 450.85; // distance between server rack side rails
sbcFullThickness = 34.0; // full height of board including PoE HAT and GPIO extensions
boardThicknessExactSBC = 1.40;
boardThicknessExactPoEHAT = 1.69;
boardThickness = 2.0; // approximate thickness of circuit boards (HAT and SBC)
sbcInterBoardThickness = 21.20; // distance between PoE HAT board and SBC board
sbcPinToEdgeDistanceExact = 1.40;
sbcPinToEdgeDistance = 1.5; // approximate lip between GPIO pins and edge of circuit board
sbcGPIOPinHeight = 7.60; // distance from HAT top to top of GPIO pins
sbcDepth = 85.00;
moduleMultiplier = 11; // modules per server rack width
mountWidth = 450.85 / moduleMultiplier;
mountHeight = 16;//63.5; // 2U height
mountStructuralQuantum = 1.5; // minimum unit for structural components
mountStructuralDepth = sbcDepth / 4;
sideWallWidth = (mountWidth - sbcFullThickness) / 2;
clipThicknessMultiplier = 6;
clipDepthMultiplier = 1.1;
unsupportedMaxExtension = mountStructuralQuantum * 2;

circleResolution=360*2; // faces per rotation

union() {
    // SBC slot
    translate ([(mountWidth / 2) - (sbcFullThickness / 2), 0, 0]) {
        union() {
            cube([
                sbcFullThickness,
                mountStructuralDepth,
                mountStructuralQuantum
            ]);
            translate([
                sbcGPIOPinHeight + boardThickness,
                0,
                0
            ]) {
                difference() {
                    cube([
                        sbcInterBoardThickness,
                        mountStructuralDepth,
                        mountStructuralQuantum + sbcPinToEdgeDistance
                    ]);
                    translate([-0.4, mountStructuralDepth - 3, -0.01]) {
    rotate([0,0,-45])                    
                        #linear_extrude(height=(mountStructuralQuantum + sbcPinToEdgeDistance) * 1.01) {
                            text("α4·NG", size=6, font="Noto Sans Mono:style=Bold");
                        }
                    }
                }
            }
        }
    }
    
    // left side panel and mount
    translate([0, 0, 0]) {
        difference() {
            cube([
                sideWallWidth,
                mountStructuralDepth,
                mountHeight,
            ]);
            translate([-0.01, -0.01, -0.01]) {
                // front clip (female)
                cube([
                    sideWallWidth * 1.01,
                    mountStructuralQuantum * 1.11,
                    mountHeight * 1.01
                ]);
                translate([mountStructuralQuantum, mountStructuralQuantum, 0]) {
                    cube([
                        sideWallWidth,
                        mountStructuralQuantum * (0.01 + clipDepthMultiplier),
                        mountHeight * 1.01
                    ]);
                }
                // back rod (female)
                translate([-0.01, mountStructuralDepth - (mountStructuralQuantum * ((clipThicknessMultiplier / 2) + 1)), mountStructuralQuantum * 8]) {
                    rotate([0, 90, 0]) {
                        cylinder(h=sideWallWidth * 4, r=mountStructuralQuantum * clipThicknessMultiplier / 2, $fn=circleResolution, center=true);
                    }
                }
            }
        }
    }
    
    // right side panel and mount
    translate([sbcFullThickness + sideWallWidth, 0, 0]) {
        cube([
            sideWallWidth,
            mountStructuralDepth,
            mountHeight,
        ]);
        // front clip (male)
        translate([0, 0, 0]) {
            cube([
                sideWallWidth + mountStructuralQuantum * 1.15,
                mountStructuralQuantum,
                mountStructuralQuantum * clipThicknessMultiplier
            ]);
            translate([sideWallWidth + mountStructuralQuantum * 1.15,0,0]) {
                cube([
                    mountStructuralQuantum / 2,
                    mountStructuralQuantum * (clipDepthMultiplier + 1),
                    mountStructuralQuantum * clipThicknessMultiplier
                ]);
            }
            translate([sideWallWidth + mountStructuralQuantum * 1.65, 0, 0]) {
                polyhedron(points = [
                    // y-plane points
                    [0,0,0],
                    [sideWallWidth - (mountStructuralQuantum * 1.55), 0, 0],
                    [0,0,mountStructuralQuantum * clipThicknessMultiplier],
                    [sideWallWidth - (mountStructuralQuantum * 1.55), 0, mountStructuralQuantum * clipThicknessMultiplier],
                    // x-plane points
                    [0, mountStructuralQuantum * (clipDepthMultiplier + 1), 0],
                    [0, mountStructuralQuantum * (clipDepthMultiplier + 1), mountStructuralQuantum * clipThicknessMultiplier]
                ], faces = [
                    [0, 2, 3, 1], //[0, 1, 2, 3],
                    [0, 4, 5, 2], //[0, 2, 4, 5],
                    [1, 3, 5, 4], //[1, 3, 4, 5],
                    [0, 1, 4],
                    [2, 5, 3]
                ]);
            }
        }
        // back rod (male)
        translate([sideWallWidth, mountStructuralDepth - (mountStructuralQuantum * ((clipThicknessMultiplier / 2) + 1)), mountStructuralQuantum * 8]) {
            rotate([0, 90, 0]) {
                cylinder(h=unsupportedMaxExtension * 2, r=mountStructuralQuantum * clipThicknessMultiplier * 0.48, $fn=circleResolution, center=true);
            }
        }
    }
}