399 lines
10 KiB
OpenSCAD
399 lines
10 KiB
OpenSCAD
include <units.inc>;
|
|
include <lib.scad>;
|
|
include <constants.scad>;
|
|
include <stock_parts.scad>;
|
|
|
|
frame_size = 20;
|
|
wall_thickness = 2;
|
|
corner_size=30;
|
|
// The length along each edge that the corner bracket takes. I.e., if
|
|
// you construct a frame of four corner brackets and 4 tubes of length
|
|
// $L-$corner_size, the distance between opposite tubes' centerlines
|
|
// will be $L.
|
|
corner_offset = frame_size / 2 + wall_thickness;
|
|
rail_diam = 8;
|
|
// distance between centerline of rail and centerline of frame Y tube.
|
|
yrail_offset = (frame_size + corner_size / 2) / 2;
|
|
|
|
ysled_extralen = frame_size; // on each end
|
|
|
|
// calculated
|
|
|
|
ysled_rail_spacing = (sled_ysize);
|
|
|
|
|
|
|
|
|
|
// Generates bar of length $l, centered on origin extending in +Z
|
|
module tslot(l) {
|
|
bom_item(printable=false, label = str("tslot(", l, "mm)"));
|
|
colorize(stock_color) {
|
|
translate([-frame_size/2, -frame_size/2, 0])
|
|
cube([frame_size, frame_size, l]);
|
|
}
|
|
}
|
|
|
|
// A corner, with tubes extending in +x and +y.
|
|
module corner_base() {
|
|
odim = frame_size/2 + wall_thickness;
|
|
ldim = frame_size/2 + corner_size;
|
|
cap_points = [[-odim, -odim],
|
|
[-odim, ldim],
|
|
[ odim, ldim],
|
|
[ ldim, odim],
|
|
[ ldim, -odim]];
|
|
difference() {
|
|
translate([0, 0, -odim])
|
|
linear_extrude(odim * 2)
|
|
polygon(points = cap_points);
|
|
|
|
// two bars...
|
|
translate([-frame_size/2, corner_offset, -frame_size/2])
|
|
cube([frame_size, ldim, frame_size]);
|
|
translate([corner_offset, -frame_size/2, -frame_size/2])
|
|
cube([ldim, frame_size, frame_size]);
|
|
translate([corner_offset, corner_offset, -frame_size/2])
|
|
cube([ldim, ldim, frame_size]);
|
|
//translate([-odim - 1, -odim - 1, 0])
|
|
//cube(ldim*2);
|
|
}
|
|
}
|
|
|
|
module rail_holder(in_x) {
|
|
odim = frame_size/2 + wall_thickness;
|
|
ldim = frame_size/2 + corner_size;
|
|
tube_offset = (corner_size) / 2 + wall_thickness;
|
|
tube_rotation = in_x ? 90 : 0;
|
|
|
|
translated_rail_offset = yrail_offset - frame_size / 2;
|
|
|
|
translate([frame_size/2, frame_size/2, -frame_size/2]) {
|
|
difference() {
|
|
linear_extrude(frame_size)
|
|
polygon(points = [[wall_thickness, wall_thickness],
|
|
[wall_thickness, corner_size],
|
|
[corner_size, wall_thickness]]);
|
|
|
|
translate([translated_rail_offset, translated_rail_offset, frame_size/2])
|
|
rotate([tube_rotation -90, tube_rotation, 0])
|
|
translate([0, 0, -corner_size])
|
|
cylinder(d = rail_diam, corner_size * 4);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
// centered on
|
|
module ysled_slider(spread, associated_parts = $preview) {
|
|
bom_item(label = str("ysled_slider(", spread, ")"));
|
|
sled_len = spread + frame_size;
|
|
sled_height = frame_size;
|
|
|
|
colorize("green")
|
|
render()
|
|
translate([0, -sled_len/2, 0])
|
|
rotate([-90, 0, 0]) {
|
|
difference() {
|
|
union() {
|
|
translate([-frame_size/2, -frame_size/2, 0])
|
|
cube([frame_size + 5, frame_size, sled_len]);
|
|
}
|
|
|
|
cylinder(d = bushing_id * 1.1, h = sled_len);
|
|
|
|
translate([0,0,-1])
|
|
cylinder(d = bushing_od, h = bushing_len+1);
|
|
translate([0,0,sled_len - bushing_len])
|
|
cylinder(d = bushing_od, h = bushing_len+1);
|
|
|
|
for (zpos = [frame_size / 2, sled_len - frame_size / 2]) {
|
|
translate([sled_height/2, 0, zpos])
|
|
rotate([0,90,0]) {
|
|
cylinder(h = sled_height + 1, d = rail_diam);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// TODO: add posts for the idlers
|
|
|
|
translate([0, -sled_len/2, 0])
|
|
rotate([-90, 0, 0])
|
|
if (associated_parts) {
|
|
bushing();
|
|
translate([0,0,sled_len - bushing_len]) bushing();
|
|
}
|
|
}
|
|
|
|
module nema17_housing() {
|
|
hwidth = corner_size + frame_size + wall_thickness;
|
|
hheight = nema17_face + wall_thickness * 2;
|
|
hdepth = frame_size + wall_thickness * 2;
|
|
|
|
screw_dxy = 31 / 2;
|
|
translate([0,
|
|
-nema17_face/2 - frame_size/2 - wall_thickness,
|
|
0])
|
|
render()
|
|
difference() {
|
|
cube([hwidth, hheight, hdepth],
|
|
center=true);
|
|
|
|
translate([0,0,-2])
|
|
cube([nema17_face+1, nema17_face+1, hdepth],
|
|
center=true);
|
|
cylinder(d=23, frame_size);
|
|
|
|
for (x = [-screw_dxy, screw_dxy],
|
|
y = [-screw_dxy, screw_dxy])
|
|
translate([x, y, frame_size/2 + wall_thickness])
|
|
rotate([180, 0, 0]){
|
|
cylinder(d=5,h=3);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
module flcorner() {
|
|
bom_item();
|
|
rotate([0, 0, 0]) {
|
|
corner_base();
|
|
rail_holder(false);
|
|
}
|
|
translate([(corner_size-wall_thickness)/2, 0, 0])
|
|
nema17_housing();
|
|
|
|
if($preview)
|
|
translate([(corner_size - wall_thickness) / 2,
|
|
-nema17_face/2 - frame_size/2 - wall_thickness,
|
|
frame_size/2]) {
|
|
nema17();
|
|
translate([0, 0, 2]) {
|
|
pulley(16,6,1,7);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
module frcorner() {
|
|
bom_item();
|
|
rotate([0, 0, 90]) {
|
|
corner_base();
|
|
rail_holder(true);
|
|
}
|
|
translate([-(corner_size-wall_thickness)/2, 0, 0])
|
|
nema17_housing();
|
|
|
|
if($preview)
|
|
translate([-(corner_size - wall_thickness) / 2,
|
|
-nema17_face/2 - frame_size/2 - wall_thickness,
|
|
frame_size/2]) {
|
|
nema17();
|
|
translate([0,0,2]) {
|
|
pulley(16, 1, 6, 7);
|
|
}
|
|
}
|
|
}
|
|
|
|
module blcorner() {
|
|
bom_item();
|
|
rotate([0, 0, 270]) {
|
|
corner_base();
|
|
rail_holder(true);
|
|
}
|
|
}
|
|
|
|
module brcorner() {
|
|
bom_item();
|
|
rotate([0, 0, 180]) {
|
|
corner_base();
|
|
rail_holder(false);
|
|
}
|
|
}
|
|
|
|
module xsled_slider() {
|
|
slider_len = bushing_len + 10;
|
|
screw_tab_len = 20;
|
|
screw_tab_thickness = 10;
|
|
|
|
render()
|
|
//translate([screw_tab_len, 0, 0])
|
|
difference() {
|
|
union() {
|
|
rotate([0, 90, 0]) {
|
|
cylinder(d = frame_size, h = slider_len);
|
|
}
|
|
|
|
translate([0, -frame_size/2, 0])
|
|
cube([slider_len, frame_size, frame_size / 2]);
|
|
|
|
*translate([-screw_tab_len, -frame_size/2, frame_size/2])
|
|
cube([screw_tab_len * 2 + slider_len, frame_size, screw_tab_thickness]);
|
|
}
|
|
rotate([0, 90, 0]) {
|
|
cylinder(d = bushing_od, h = bushing_len);
|
|
cylinder(d = rail_diam * 1.1, slider_len * 2);
|
|
}
|
|
|
|
}
|
|
if($preview)
|
|
rotate([0, 90, 0])
|
|
bushing();
|
|
}
|
|
|
|
module sled_cornera() {
|
|
bom_item();
|
|
corner_base();
|
|
translate([-frame_size/2 - wall_thickness, 0, -frame_size])
|
|
xsled_slider();
|
|
}
|
|
|
|
module sled_cornerb() {
|
|
bom_item();
|
|
corner_base();
|
|
rotate([0,0,90])
|
|
translate([-frame_size/2 - wall_thickness, 0, -frame_size])
|
|
xsled_slider();
|
|
}
|
|
|
|
module xsled_frame() {
|
|
translate([-sled_xsize / 2 + corner_offset, -ysled_rail_spacing/2, 0])
|
|
rotate([0, 90, 0])
|
|
tslot(sled_xsize - corner_offset * 2);
|
|
translate([-sled_xsize / 2 + corner_offset, ysled_rail_spacing/2, 0])
|
|
rotate([0, 90, 0])
|
|
tslot(sled_xsize - corner_offset * 2);
|
|
translate([-sled_xsize / 2, -ysled_rail_spacing/2 + corner_offset, 0])
|
|
rotate([-90, 0, 0])
|
|
tslot(sled_ysize - corner_offset * 2);
|
|
translate([sled_xsize / 2, -ysled_rail_spacing/2 + corner_offset, 0])
|
|
rotate([-90, 0, 0])
|
|
tslot(sled_ysize - corner_offset * 2);
|
|
|
|
translate([-sled_xsize / 2, -sled_ysize / 2, 0])
|
|
sled_cornera();
|
|
translate([sled_xsize / 2, sled_ysize / 2, 0])
|
|
rotate([0,0,180])
|
|
sled_cornera();
|
|
|
|
translate([sled_xsize / 2, -sled_ysize / 2, 0])
|
|
rotate([0,0,90])
|
|
sled_cornerb();
|
|
translate([-sled_xsize / 2, sled_ysize / 2, 0])
|
|
rotate([0,0,270])
|
|
sled_cornerb();
|
|
|
|
|
|
// simulate a piece of film
|
|
if (false) {
|
|
color("#0008")
|
|
cube([
|
|
5*inch,
|
|
4*inch,
|
|
1
|
|
],
|
|
center=true);
|
|
}
|
|
}
|
|
|
|
module xsled2() {
|
|
bom_item();
|
|
|
|
tab_len = bushing_len * 2;
|
|
tab_thickness = bushing_od + wall_thickness * 2;
|
|
glass_thickness = 3; // TODO: Update when an actual size is available
|
|
|
|
inner_ysize = sled_ysize - tab_thickness;
|
|
|
|
lip_depth = tab_thickness - wall_thickness - glass_thickness;
|
|
lip_width = glass_thickness;
|
|
|
|
glass_holder_points = [
|
|
[0,0],
|
|
[lip_depth + wall_thickness, 0],
|
|
[lip_depth + wall_thickness, wall_thickness + 0.5],
|
|
[lip_depth, wall_thickness + 0.5],
|
|
[lip_depth, wall_thickness + glass_thickness],
|
|
[lip_depth - glass_thickness, wall_thickness + glass_thickness],
|
|
[lip_depth - glass_thickness, wall_thickness + glass_thickness*2],
|
|
[0, tab_thickness]
|
|
];
|
|
|
|
|
|
for (xsign = [1,-1],
|
|
ysign = [1,-1]) {
|
|
translate([sled_xsize / 2 * xsign,
|
|
sled_ysize / 2 * ysign,
|
|
0])
|
|
rotate([0, -90 * xsign, 0]) {
|
|
difference() {
|
|
union() {
|
|
cylinder(d = tab_thickness, h = tab_len);
|
|
translate([-tab_thickness/2,
|
|
ysign > 0 ? -tab_thickness/2: 0,
|
|
0])
|
|
cube([tab_thickness, tab_thickness/2, tab_len]);
|
|
}
|
|
translate([0,0,-0.5]) {
|
|
cylinder(d = bushing_od, h = bushing_len+0.5);
|
|
cylinder(d = rail_diam * 1.1 , h = tab_len + 1);
|
|
}
|
|
}
|
|
if ($preview) {
|
|
bushing();
|
|
}
|
|
}
|
|
|
|
//cube([sled_xsize, inner_ysize, tab_thickness/2], center=true);
|
|
difference() {
|
|
union() {
|
|
translate([-sled_xsize/2, -inner_ysize/2, -tab_thickness/2])
|
|
rotate([0, 90, 0])
|
|
rotate([0,0,90])
|
|
linear_extrude(sled_xsize)
|
|
polygon(glass_holder_points);
|
|
|
|
translate([sled_xsize/2, inner_ysize/2, -tab_thickness/2])
|
|
rotate([0, 90, 180])
|
|
rotate([0,0,90])
|
|
linear_extrude(sled_xsize)
|
|
polygon(glass_holder_points);
|
|
|
|
translate([sled_xsize/2, -inner_ysize/2, -tab_thickness/2])
|
|
rotate([0, 90, 90])
|
|
rotate([0,0,90])
|
|
linear_extrude(inner_ysize)
|
|
polygon(glass_holder_points);
|
|
|
|
translate([-sled_xsize/2, inner_ysize/2, -tab_thickness/2])
|
|
rotate([0, 90, -90])
|
|
rotate([0,0,90])
|
|
linear_extrude(inner_ysize)
|
|
polygon(glass_holder_points);
|
|
}
|
|
|
|
translate([-10, inner_ysize/2 - 1 - lip_depth + glass_thickness, -tab_thickness/2 + wall_thickness + glass_thickness])
|
|
cube([20, glass_thickness + 1, 30]);
|
|
}
|
|
}
|
|
|
|
color("#fff3")
|
|
if ($preview) {
|
|
// draw glass sheets
|
|
translate([0,0,-tab_thickness/2 + wall_thickness + glass_thickness/2])
|
|
cube([sled_xsize - lip_depth*2, inner_ysize - lip_depth*2, glass_thickness],
|
|
center=true);
|
|
translate([0,0,-tab_thickness/2 + wall_thickness + 3*glass_thickness/2])
|
|
cube(
|
|
[
|
|
sled_xsize - lip_depth*2 + glass_thickness*2,
|
|
inner_ysize - lip_depth*2 + glass_thickness*2,
|
|
glass_thickness
|
|
],
|
|
center=true);
|
|
|
|
}
|
|
}
|
|
// render()
|
|
// xsled2();
|
|
|