200 lines
7.1 KiB
OpenSCAD
200 lines
7.1 KiB
OpenSCAD
rack_units = 2;
|
|
device_width = 156; // .0001
|
|
device_height = 81; // .0001
|
|
device_depth = 156; // .0001
|
|
|
|
panel_width = 254;
|
|
panel_height = rack_units * 44.45;
|
|
panel_thickness = 4; // .0001
|
|
shelf_thickness = 4; // .00001
|
|
lip_height = 4; // .0001
|
|
lip_thickness = 4; // .0001
|
|
gusset_thickness = 4; // .0001
|
|
gusset_depth = 40; // .0001
|
|
gusset_height = 30; // .0001
|
|
topshelf_depth = 0; // .0001
|
|
hole_diameter = 7; // .0001
|
|
hole_offset_x = 8; // .0001
|
|
hole_offset_y = 6.25; // .0001
|
|
corner_radius = 3.81; // .0001
|
|
// Derived dimensions
|
|
cutout_width = device_width;
|
|
cutout_height = device_height;
|
|
cutout_x = (panel_width - cutout_width) / 2;
|
|
cutout_y = shelf_thickness;
|
|
shelf_depth = device_depth + lip_thickness; // Device depth plus 0.25 inches
|
|
|
|
|
|
$fn = 32;
|
|
|
|
module roundedcube(size = [1, 1, 1], center = false, radius = 0.5, apply_to = "all") {
|
|
// If single value, convert to [x, y, z] vector
|
|
size = (size[0] == undef) ? [size, size, size] : size;
|
|
|
|
//echo(str("roundedcube([",size[0],size[1],size[2],"], radius=", radius, ", apply_to=",apply_to));
|
|
translate_min = 0;
|
|
translate_xmax = size[0];
|
|
translate_ymax = size[1];
|
|
translate_zmax = size[2];
|
|
|
|
diameter = radius * 2;
|
|
|
|
function adj2(i,dt,df) = (i==0)?dt:df;
|
|
function adj(i,d) = adj2(i,d,-d);
|
|
function adjR(i) = adj(i,radius);
|
|
|
|
obj_translate = (center == false) ?
|
|
[0, 0, 0] : [
|
|
-(size[0] / 2),
|
|
-(size[1] / 2),
|
|
-(size[2] / 2)
|
|
];
|
|
|
|
translate(v = obj_translate) {
|
|
hull() {
|
|
for (xi = [0:1]) {
|
|
translate_x = [translate_min, translate_xmax][xi];
|
|
x_at = (xi == 0) ? "min" : "max";
|
|
for (yi = [0:1]) {
|
|
translate_y = [translate_min, translate_ymax][yi];
|
|
y_at = (yi == 0) ? "min" : "max";
|
|
for (zi = [0:1]) {
|
|
translate_z = [translate_min, translate_zmax][zi];
|
|
z_at = (zi == 0) ? "min" : "max";
|
|
|
|
if (
|
|
(apply_to == "all") ||
|
|
(apply_to == "xmin" && x_at == "min") || (apply_to == "xmax" && x_at == "max") ||
|
|
(apply_to == "ymin" && y_at == "min") || (apply_to == "ymax" && y_at == "max") ||
|
|
(apply_to == "zmin" && z_at == "min") || (apply_to == "zmax" && z_at == "max")
|
|
) {
|
|
// GGS: Separate translates to asccomodate changes allowing sizes < 3 x radius
|
|
translate(v = [translate_x+adjR(xi), translate_y+adjR(yi), translate_z+adjR(zi)])
|
|
sphere(r = radius);
|
|
} else {
|
|
rotate =
|
|
(apply_to == "xmin" || apply_to == "xmax" || apply_to == "x") ? [0, 90, 0] : (
|
|
(apply_to == "ymin" || apply_to == "ymax" || apply_to == "y") ? [90, 90, 0] :
|
|
[0, 0, 0]
|
|
);
|
|
//Compute cylinder height to make it work with cubbe sizes up to 3xradius which did not work
|
|
// in original because cylinders would "eat" spheres
|
|
h1 =
|
|
(apply_to == "xmin" || apply_to == "xmax" || apply_to == "x") ? size[0]-radius : (
|
|
(apply_to == "ymin" || apply_to == "ymax" || apply_to == "y") ? size[1]-radius :
|
|
size[2]-radius
|
|
);
|
|
h2 =
|
|
(apply_to == "xmin" || apply_to == "xmax" || apply_to == "x") ? size[0]/4 : (
|
|
(apply_to == "ymin" || apply_to == "ymax" || apply_to == "y") ? size[1]/4 :
|
|
size[2]/4
|
|
);
|
|
h=(h1<h2 && h1>0)?h1:h2;
|
|
height=(h<radius)?h:radius;
|
|
echo(height);
|
|
|
|
trans =
|
|
(apply_to == "xmin" || apply_to == "xmax" || apply_to == "x") ? [adj2(xi,0,-height),adjR(yi),adjR(zi)] : (
|
|
(apply_to == "ymin" || apply_to == "ymax" || apply_to == "y") ? [adjR(xi),adj2(yi,0,-height),adjR(zi)] :
|
|
[adjR(xi),adjR(yi),adj2(zi,0,-height)]
|
|
);
|
|
//echo(trans);
|
|
translate(v = [translate_x+trans[0], translate_y+trans[1]+height, translate_z+trans[2]])
|
|
rotate(a = rotate)
|
|
cylinder(h = height, r = radius, center = false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
module front_panel() {
|
|
difference() {
|
|
// Front panel
|
|
//cube([panel_width, panel_thickness, panel_height]);
|
|
roundedcube([panel_width, panel_thickness, panel_height], false, corner_radius, "y");
|
|
|
|
// Centered rectangular cutout
|
|
translate([cutout_x, -1, cutout_y])
|
|
cube([cutout_width, panel_thickness + 2, cutout_height]);
|
|
|
|
// Mounting holes
|
|
for (x_pos = [hole_offset_x, panel_width - hole_offset_x])
|
|
for (z_pos = [hole_offset_y, panel_height - hole_offset_y])
|
|
translate([x_pos, panel_thickness + 1, z_pos])
|
|
rotate([90, 0, 0])
|
|
cylinder(h = panel_thickness + 2, d = hole_diameter, $fn = 32);
|
|
}
|
|
}
|
|
|
|
module support_shelf() {
|
|
// Align top of shelf with bottom of cutout
|
|
shelf_z = cutout_y;
|
|
|
|
// Shelf
|
|
translate([cutout_x - gusset_thickness, panel_thickness, shelf_z - min(shelf_thickness, (panel_height - device_height) / 2)])
|
|
cube([cutout_width + gusset_thickness * 2, shelf_depth, min(shelf_thickness, (panel_height - device_height) / 2)]);
|
|
|
|
// Back lip
|
|
translate([cutout_x + device_width / 4, panel_thickness + shelf_depth - lip_thickness, shelf_z ])
|
|
cube([cutout_width / 2, lip_thickness, lip_height]);
|
|
}
|
|
|
|
module topshelf() {
|
|
// Align top of shelf with bottom of cutout
|
|
shelf_z = cutout_y + device_height;
|
|
|
|
// Shelf
|
|
translate([cutout_x - gusset_thickness, panel_thickness, shelf_z - min(shelf_thickness, (panel_height - device_height) / 2)])
|
|
cube([cutout_width + gusset_thickness * 2, topshelf_depth, min(shelf_thickness, (panel_height - device_height) / 2)]);
|
|
|
|
// Left Side
|
|
translate([cutout_x - gusset_thickness, panel_thickness, shelf_z - min(shelf_thickness, (panel_height - device_height) / 2)])
|
|
rotate([0,90,0])
|
|
cube([device_height, topshelf_depth, min(shelf_thickness, (panel_height - device_height) / 2)]);
|
|
|
|
// Right Side
|
|
translate([cutout_x + device_width, panel_thickness, shelf_z - min(shelf_thickness, (panel_height - device_height) / 2)])
|
|
rotate([0,90,0])
|
|
cube([device_height, topshelf_depth, min(shelf_thickness, (panel_height - device_height) / 2)]);
|
|
|
|
}
|
|
|
|
module gusset() {
|
|
// Gusset dimensions
|
|
//gusset_depth = shelf_depth / 2;
|
|
//gusset_height = cutout_height / 2;
|
|
|
|
// Create a right-angled triangle and extrude it
|
|
linear_extrude(height = gusset_thickness)
|
|
polygon(points = [[0, 0], [gusset_depth, 0], [0, gusset_height]]);
|
|
}
|
|
|
|
module gussets() {
|
|
// Positioning the gussets on either side of the shelf
|
|
shelf_z = cutout_y;
|
|
|
|
// Left gusset
|
|
translate([cutout_x - gusset_thickness, panel_thickness + topshelf_depth, shelf_z])
|
|
rotate([90, 0, 90])
|
|
gusset();
|
|
|
|
// Right gusset
|
|
translate([cutout_x + cutout_width, panel_thickness + topshelf_depth, shelf_z])
|
|
rotate([90, 0, 90])
|
|
gusset();
|
|
}
|
|
|
|
// Assemble the rack mount
|
|
//rotate([90, 0, 0])
|
|
translate([-panel_width / 2, 0, -panel_height / 2])
|
|
union() {
|
|
front_panel();
|
|
support_shelf();
|
|
topshelf();
|
|
gussets();
|
|
}
|
|
|