2U Mini PC 10in Rack Mounts

THIS IS A WIP - I'll probably be updating this again later! 

Feel free to flip the model on its face to make things simpler with support. I just threw it on the plate for the upload. 

Oh hi! I've adopted this 10in fan rack mount to design a couple of rack mounts for a Minisforum NAB9 and a Topgro fanless SFF Mini PC. I hope this helps someone random out there. I essentially created my own faceplate and base using a parametric model design in OpenSCAD. The parametric model design is truly a WIP, but the faceplate / base is easily there. So I used this awesome and structurally sound fan rack mount (or rather, it's sexy curved brace) and remixed it with the generated faceplate / base.  Also added some very quick stops (lol…very quick) for the back of the mini PCs. If anyone would like to help me iron out the OpenSCAD, just let me know. I'm a novice and will gladly accept the help. Otherwise, you'll just see a new parametric 10in mini rack model maker pop up later. Variables up top if you want to modify any measurements.

I personally printed with ABS-GF, but stick to something that can withstand the temps. These little PCs don't often weigh a ton and this should hopefully be able to handle them easily. Test at your own risk of course. I assume no liability and the flurry of other statements. 

You can thank a kind redditor for pushing me to post this. If you wanna generate your own rack mount, continue below - currently commented everything out except for faceplate generation. My goal is to work towards the design in the OpenSCAD. I also intend on adding optional back bracing for the rack for heavier machines.

Here's the OpenSCAD (also attached in documentation as a text file):

// Revised 2U Parametric Rack Mount Shelf for Mini PCs
// Tested against OpenSCAD v2021.01+ documentation

// ========== PARAMETERS ==========
faceplate_width   = 254;       // mm, standard 10-inch rack width
faceplate_height  = 88.9;        // mm, standard 2U height (~3.5 inches)
plate_thickness   = 5;           // mm, thickness of the faceplate and braces

hole_diameter     = 7;           // mm, mounting hole nominal diameter
hole_slot_length  = 10;          // mm, total length of the oblong mounting slot

ear_hole_offset_x = 8.75;        // mm, horizontal offset from faceplate edge to hole center
extra_margin      = 5;           // mm, extra margin for shelf to avoid interference with rack ears
shelf_width       = faceplate_width - 2*(ear_hole_offset_x + hole_diameter/2 + extra_margin);
shelf_depth       = 150;         // mm, 10-inch depth by default
shelf_thickness   = 3;           // mm, thickness of the shelf base

cutout_width      = 155;         // mm, width of the front cutout on the faceplate
cutout_height     = 30;          // mm, height of the front cutout
cutout_bottom_gap = 10;          // mm, vertical gap from bottom of faceplate to cutout

// Honeycomb vent parameters (for the shelf base)
hex_side          = 5;           // mm, side length for each hexagonal cell
hex_gap           = 1;           // mm, gap between hex cells (printable wall thickness)
vent_diameter     = 130;         // mm, overall diameter of the vent region

// Curved brace parameters
brace_segments    = 20;          // number of segments used to approximate the brace curve

// ========== HELPER FUNCTIONS ==========
// Converts degrees to radians.
function deg2rad(a) = a * (3.14159265358979 / 180);

// ========== MODULES ==========

// Module: Regular hexagon (flat-topped), centered at origin
module regular_hexagon(side) {
   // Calculate the apothem (distance from center to flat side)
   apothem = cos(30) * side;
   polygon(points=[
       [ side/2,  apothem],
       [ side,    0],
       [ side/2, -apothem],
       [-side/2, -apothem],
       [-side,    0],
       [-side/2,  apothem]
   ]);
}

// Module: Honeycomb vent pattern within a circular area (2D)
module honeycomb_vent_pattern() {
   union() {
       // Calculate grid dimensions based on cell size
       cols = ceil(vent_diameter / (1.5 * hex_side)) + 2;
       rows = ceil(vent_diameter / (1.732 * hex_side)) + 2;  // 1.732 ~ sqrt(3)
       for (i = [-cols/2 : cols/2], j = [-rows/2 : rows/2]) {
           // Offset every other column for tight packing (approx. 0.866 * side)
           y_offset = (i % 2) * (0.866 * hex_side);
           x_pos = i * (1.5 * hex_side);
           y_pos = j * (1.732 * hex_side) + y_offset;
           // Only keep hexagons whose centers fall within the vent circle
           if ((x_pos*x_pos + y_pos*y_pos) <= (vent_diameter/2)*(vent_diameter/2)) {
               translate([shelf_width/2 + x_pos, shelf_depth/2 + y_pos])
                   offset(delta = -hex_gap/2) regular_hexagon(hex_side);
           }
       }
   }
}

// Module: Faceplate profile (2D) with mounting holes and a centered cutout
module faceplate_profile_2d() {
   difference() {
       square([faceplate_width, faceplate_height]);
       // Subtract the centered cutout rectangle (for ports or ventilation)
       translate([(faceplate_width - cutout_width)/2, cutout_bottom_gap])
           square([cutout_width, cutout_height]);
       // Mounting holes (oblong shapes): 4 holes per side in a 2U layout
       hole_y_positions = [6.35, 38.1, faceplate_height - 38.1, faceplate_height - 6.35];
       for (y_pos = hole_y_positions)
           for (x_pos = [ear_hole_offset_x, faceplate_width - ear_hole_offset_x])
               translate([x_pos, y_pos]) oblong_hole(hole_slot_length, hole_diameter);
   }
}

// Module: Oblong (oval) mounting hole shape (vertical orientation)
module oblong_hole(slot_length, slot_width) {
   union() {
       // Vertical rectangle centered at (0,0)
       square([slot_width, slot_length - slot_width], center = true);
       // Top semicircular cap
       translate([0, (slot_length - slot_width)/2])
           circle(d = slot_width, $fn = 30);
       // Bottom semicircular cap
       translate([0, -(slot_length - slot_width)/2])
           circle(d = slot_width, $fn = 30);
   }
}

// Module: Shelf base plate with a honeycomb vent cutout (2D)
module shelf_plate_2d() {
   difference() {
       square([shelf_width, shelf_depth]);
       // Intersect the circular vent region with the honeycomb pattern
       intersection() {
           translate([shelf_width/2, shelf_depth/2])
               circle(r = vent_diameter/2);
           honeycomb_vent_pattern();
       }
   }
}

// Module: Curved support brace (for one side)
// This module constructs a quarter-arc shape from the shelf’s rear-bottom to the faceplate's top.
//module curved_brace_side(isRight = true) {
//    // Calculate the two base points: front-bottom (0,0) and rear-bottom (shelf_depth,0)
//    base_points = [[0, 0], [shelf_depth, 0]];
//    
//    // Generate arc points along a quarter circle from (shelf_depth,0) to (0,faceplate_height)
//    arc_points = [
//        for (seg = [1 : brace_segments - 1])
//            [
//                shelf_depth * cos(deg2rad(90 * seg / brace_segments)),
//                faceplate_height * sin(deg2rad(90 * seg / brace_segments))
//            ]
//    ];
//    
//    // Top point at (0, faceplate_height)
//    top_point = [[0, faceplate_height]];
//    
//    // Combine all points in order (base, arc, top)
//    brace_points = concat(base_points, arc_points, top_point);
//    
//    // Extrude the 2D brace shape to create a 3D object
//    brace_shape = linear_extrude(height = plate_thickness)
//        polygon(points = brace_points);
//    
//    // Position the brace on the correct side, with a slight overlap for proper union
//    if (isRight) {
//        // Right side: shift to the right edge (with a -1 mm offset) and a forward offset (0.1 mm)
//        translate([(faceplate_width + shelf_width)/2 - 1, plate_thickness - 0.1, 0])
//            rotate([0, 90, 0]) brace_shape;
//    } else {
//        // Left side: shift to the left edge (+1 mm offset) and a forward offset (0.1 mm)
//        translate([(faceplate_width - shelf_width)/2 + 1, plate_thickness - 0.1, 0])
//            rotate([0, 90, 0]) brace_shape;
//    }
//}

// ========== MAIN ASSEMBLY ==========
union() {
   // Faceplate:
   // Rotate the 2D faceplate profile to stand vertically and extrude it.
   rotate([-90, 0, 0])
       linear_extrude(height = plate_thickness)
           faceplate_profile_2d();
   
   // Shelf base:
   // Place the shelf base directly behind the faceplate.
   // Note the 0.1 mm translation to ensure a proper overlap (solid manifold union).
   //translate([(faceplate_width - shelf_width)/2, plate_thickness - 0.1, 0])
   //    linear_extrude(height = shelf_thickness)
   //        shelf_plate_2d();
   
   // Curved support braces on both sides:
   // curved_brace_side(isRight = true);
   // curved_brace_side(isRight = false);
}