284 lines
9.7 KiB
OpenSCAD
284 lines
9.7 KiB
OpenSCAD
CF_Tube_Len = 420; // Convenient Amazon size, longer would be better of course but prices are important
|
|
CF_Tube_OD = 5.0; // Outer Diameter
|
|
CF_Tube_ID = 3.0;
|
|
CF_Square_Width = 6.0;
|
|
CF_Square_ID = 5.0; // Inner diameter, sadly doesn't fit the tubes
|
|
|
|
cyl_hd_fn = $preview ? 32 : 512;
|
|
cyl_ld_fn = $preview ? 24 : 72;
|
|
|
|
module Dowel() {
|
|
h = 27;
|
|
rotate([-90, 0, 0]) {
|
|
$fn=72;
|
|
translate([0, 0, -h/2]) cylinder_beak(d=5.25, h=h);
|
|
hull() {
|
|
cylinder(d=6, h=0.00001, center=true);
|
|
cylinder_outer(d=5.25, h=3, center=true);
|
|
}
|
|
}
|
|
}
|
|
|
|
module CFTube(hole=true) { // Align +y
|
|
rotate([0, 0, 90]) render() difference() {
|
|
rotate([0, 90, 0]) cylinder(h=CF_Tube_Len, d=CF_Tube_OD, $fn=cyl_hd_fn);
|
|
if (hole) rotate([0, 90, 0]) cylinder(h=CF_Tube_Len, d=CF_Tube_ID, $fn=cyl_ld_fn);
|
|
}
|
|
}
|
|
module CFSquare(hole=true) {
|
|
rotate([0, 0, 90]) render() difference() {
|
|
translate([0, -CF_Square_Width/2, -CF_Square_Width/2]) cube([CF_Tube_Len, CF_Square_Width, CF_Square_Width]);
|
|
if (hole) rotate([0, 90, 0]) cylinder(h=CF_Tube_Len, d=CF_Square_ID, $fn=cyl_ld_fn);
|
|
}
|
|
}
|
|
|
|
|
|
hull_epsilon = 0.2;
|
|
module CFTubeCutout(x1, x2, tolerance = CF_Tube_OD_tolerance, VLH = false, taper_length = 5) {
|
|
tolerance = tolerance + (VLH ? 0.3 : 0);
|
|
taper_mul = 1.2;
|
|
taper_direction = (x1 > x2) ? (-1) : 1;
|
|
x_min = min(x1, x2);
|
|
x_max = max(x1, x2);
|
|
$fn = 360;
|
|
translate([0, x_min, 0])
|
|
rotate([-90,0,0])
|
|
cylinder(h=x_max-x_min, d=CF_Tube_OD+tolerance);
|
|
hull() {
|
|
translate([0, x1])
|
|
rotate([-90,0,0])
|
|
cylinder(h=hull_epsilon, d=(CF_Tube_OD*taper_mul)+tolerance);
|
|
translate([0, x1+(taper_length*taper_direction)])
|
|
rotate([-90,0,0])
|
|
cylinder(h=hull_epsilon, d=CF_Tube_OD+tolerance);
|
|
}
|
|
hull() {
|
|
translate([0, x2])
|
|
rotate([-90,0,0])
|
|
cylinder(h=hull_epsilon, d=(CF_Tube_OD*taper_mul)+tolerance);
|
|
translate([0, x2-(taper_length*taper_direction)])
|
|
rotate([-90,0,0])
|
|
cylinder(h=hull_epsilon, d=CF_Tube_OD+tolerance);
|
|
}
|
|
}
|
|
|
|
module CFSquareCutout(x1, x2, tolerance = CF_Square_Width_tolerance, taper_x1 = true, taper_x2 = true, taper_length = 5) {
|
|
x = CF_Square_Width+tolerance;
|
|
taper_mul = 1.2;
|
|
taper_direction = (x1 > x2) ? (-1) : 1;
|
|
x_min = min(x1, x2);
|
|
x_max = max(x1, x2);
|
|
translate([-x/2, x_min, -x/2]) cube([x, x_max-x_min, x]);
|
|
if (taper_x1) {
|
|
hull() {
|
|
translate([0, x1, 0])
|
|
cube([x*taper_mul, hull_epsilon, x*taper_mul], center=true);
|
|
translate([0, x1+(taper_length*taper_direction), 0])
|
|
cube([x, hull_epsilon, x], center=true);
|
|
}
|
|
}
|
|
if (taper_x2){
|
|
hull() {
|
|
translate([0, x2, 0])
|
|
cube([x*taper_mul, hull_epsilon, x*taper_mul], center=true);
|
|
translate([0, x2-(taper_length*taper_direction), 0])
|
|
cube([x, hull_epsilon, x], center=true);
|
|
}
|
|
}
|
|
}
|
|
|
|
module CFTubeCutout2(v, block_y0, block_y1, tolerance = CF_Tube_OD_tolerance, VLH = false, taper_length = 2, taper_mul = 1.1, notch = true, tolerance_length = CF_Square_Width_tolerance) {
|
|
// Alternate approach: supply start vector v, and the bounding y values of the piece, taper on entry points only.
|
|
tolerance = tolerance + (VLH ? 0.3 : 0);
|
|
tube_y0 = v[1];
|
|
tube_y1 = tube_y0 + CF_Tube_Len;
|
|
OD = CF_Tube_OD + tolerance;
|
|
taper_OD = (CF_Tube_OD*taper_mul) + tolerance;
|
|
|
|
$fn = 360;
|
|
// Full cylinder, unconditional
|
|
translate(v) translate([0, -tolerance_length, 0]) hull() {
|
|
rotate([-90,0,0]) cylinder(h=CF_Tube_Len+tolerance_length*2, d=OD);
|
|
if (notch) translate([-OD*0.02, 0, -OD*0.6]) cube([OD*0.04, CF_Tube_Len, OD*0.6]);
|
|
}
|
|
|
|
// Check for tapered holes
|
|
if ((block_y0 >= tube_y0) && (block_y0 < tube_y1)) // Tube protrudes through start of block
|
|
hull() {
|
|
translate([v[0], block_y0, v[2]])
|
|
rotate([-90,0,0]) cylinder(h=hull_epsilon, d=taper_OD);
|
|
translate([v[0], block_y0+taper_length, v[2]])
|
|
rotate([-90,0,0]) cylinder(h=hull_epsilon, d=OD);
|
|
}
|
|
if ((block_y1 <= tube_y1) && (block_y1 > tube_y0)) // Tube protrudes through end of block
|
|
hull() {
|
|
translate([v[0], block_y1-hull_epsilon, v[2]])
|
|
rotate([-90,0,0]) cylinder(h=hull_epsilon, d=taper_OD);
|
|
translate([v[0], block_y1-hull_epsilon-taper_length, v[2]])
|
|
rotate([-90,0,0]) cylinder(h=hull_epsilon, d=OD);
|
|
}
|
|
}
|
|
|
|
module CFSquareCutout2(v, block_y0, block_y1, tolerance = CF_Square_Width_tolerance, taper_length = 2, taper_mul = 1.1, tolerance_length = CF_Square_Width_tolerance) {
|
|
w = CF_Square_Width + tolerance;
|
|
taper_w = (CF_Square_Width * taper_mul) + tolerance;
|
|
tube_y0 = v[1];
|
|
tube_y1 = tube_y0 + CF_Tube_Len;
|
|
|
|
// Full square rod, unconditional
|
|
translate([v[0]-w/2, v[1] - tolerance_length, v[2]-w/2]) cube([w, CF_Tube_Len + tolerance_length*2, w]);
|
|
// Check for tapered holes
|
|
if ((block_y0 >= tube_y0) && (block_y0 < tube_y1)) // Tube protrudes through start of block
|
|
hull() {
|
|
translate([v[0], block_y0, v[2]])
|
|
cube([taper_w, hull_epsilon*2, taper_w], center=true);
|
|
translate([v[0], block_y0+taper_length, v[2]])
|
|
cube([w, hull_epsilon*2, w], center=true);
|
|
}
|
|
if ((block_y1 <= tube_y1) && (block_y1 > tube_y0)) // Tube protrudes through end of block
|
|
hull() {
|
|
translate([v[0], block_y1-hull_epsilon, v[2]])
|
|
cube([taper_w, hull_epsilon*2, taper_w], center=true);
|
|
translate([v[0], block_y1-hull_epsilon-taper_length, v[2]])
|
|
cube([w, hull_epsilon*2, w], center=true);
|
|
}
|
|
}
|
|
|
|
module TrussRodGeneric(length, tolerance, stages, taper_l = 1.5, taper_extra = 1.0, taper_points=[], extra=false) {
|
|
$fn = 360;
|
|
epsilon = 0.00000001;
|
|
rot = [-90, 180, 0];
|
|
|
|
module squircle(d, h, w) {
|
|
sq_h = max(h-d, epsilon);
|
|
render() hull() {
|
|
circle_outer(d = d);
|
|
translate([-w/2, h - d/2 - sq_h]) square([w, sq_h]);
|
|
}
|
|
}
|
|
|
|
for (s = stages) rotate(rot) linear_extrude(s[0]) squircle(s[1], s[2], s[3]);
|
|
for (i = [0:len(stages)-2]) {
|
|
s0 = stages[i];
|
|
s1 = stages[i+1];
|
|
translate([0, s0[0], 0]) hull() {
|
|
rotate(rot) linear_extrude(epsilon) squircle(s0[1], s0[2], s0[3]);
|
|
rotate(rot) linear_extrude(taper_l) squircle(s1[1], s1[2], s1[3]);
|
|
}
|
|
}
|
|
if (extra) {
|
|
l = 33;
|
|
s = stages[0];
|
|
translate([0, -l, 0]) rotate(rot) linear_extrude(l+s[0]) squircle(s[1], s[2], s[3]);
|
|
}
|
|
|
|
// Tapers
|
|
for (x = taper_points) {
|
|
larger_stages = [ for (s = stages) if (s[0] >= x) s];
|
|
if (len(larger_stages)) {
|
|
s = larger_stages[0];
|
|
t2 = taper_extra * 2;
|
|
render() hull() {
|
|
translate([0, x-epsilon/2, 0]) rotate(rot) linear_extrude(epsilon) squircle(s[1]+t2, s[2]+t2, s[3]+t2);
|
|
translate([0, x+taper_l-epsilon, 0]) rotate(rot) linear_extrude(epsilon) squircle(s[1], s[2], s[3]);
|
|
translate([0, x-taper_l, 0]) rotate(rot) linear_extrude(epsilon) squircle(s[1], s[2], s[3]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
module TrussRod(length = 630, tolerance = 0, taper_l = 3.0, taper_extra = 1.0, taper_points=[], extra=false) {
|
|
// base profile
|
|
base_d = 6.0 + tolerance;
|
|
base_w = base_d;
|
|
base_h = 9.0 + tolerance;
|
|
|
|
// nut?
|
|
stage2_d = 7.05 + 0.05 + tolerance;
|
|
stage2_w = base_w;
|
|
stage2_h = base_h + (stage2_d - base_d);
|
|
stage2_l = 55 + tolerance;
|
|
|
|
// Turning end
|
|
stage3_d = 9.2 + tolerance;
|
|
stage3_w = stage3_d;
|
|
stage3_h = base_h + (stage3_d - base_d);
|
|
stage3_l = 35 + tolerance;
|
|
|
|
// Rod outline
|
|
stages = [ // Must be ascending order for later
|
|
[stage3_l, stage3_d, stage3_h, stage3_w],
|
|
[stage2_l, stage2_d, stage2_h, stage2_w],
|
|
[length, base_d, base_h, base_w],
|
|
];
|
|
TrussRodGeneric(length=length, tolerance=tolerance, stages=stages, taper_l=taper_l, taper_extra=taper_extra, taper_points=taper_points, extra=extra);
|
|
}
|
|
module TrussRodSingleAction(length = 460, tolerance = 0, taper_l = 3.0, taper_extra = 1.0, taper_points=[], extra=false) {
|
|
// base profile
|
|
base_d = 4.6 + tolerance;
|
|
base_w = 6.1 + tolerance;
|
|
base_h = 8.1 + tolerance;
|
|
|
|
// nut?
|
|
stage2_d = 7.0 + 0.8 + tolerance;
|
|
stage2_w = base_w;
|
|
stage2_h = base_h + (stage2_d - base_d);
|
|
stage2_l = 44 + tolerance;
|
|
|
|
// Rod outline
|
|
stages = [ // Must be ascending order for later
|
|
[stage2_l, stage2_d, stage2_h, stage2_w],
|
|
[length, base_d, base_h, base_w],
|
|
];
|
|
TrussRodGeneric(length=length, tolerance=tolerance, stages=stages, taper_l=taper_l, taper_extra=taper_extra, taper_points=taper_points, extra=extra);
|
|
}
|
|
|
|
|
|
module TrussRods(extra=0, tolerance=0.6) {
|
|
for (rod = $trussrod_positions) {
|
|
pos = rod[0];
|
|
rot = rod[1];
|
|
m = rod[2];
|
|
// Transform absolute taper points to relate to the position and rotation of the rod
|
|
// Currently this will only work well for truss rods aligned along the Y axis
|
|
y_mul = cos(rot[2]); // This should be +1 for 0 rotation, -1 for 180 rotation. Incomplete for now, only covers 180° Z rotation.
|
|
taper_points = [ for (y = $segment_cuts) y_mul*(y - pos[1]) ];
|
|
// echo(rod, y_mul, taper_points)
|
|
translate(pos) rotate(rot) {
|
|
if (m == "TrussRodSingleAction") TrussRodSingleAction(extra=$trussrods_extra, tolerance=tolerance, taper_points=taper_points);
|
|
if (m == "TrussRod") TrussRod(extra=$trussrods_extra, tolerance=tolerance, taper_points=taper_points);
|
|
}
|
|
}
|
|
}
|
|
module CFs(taper_length = 2, taper_mul = 1.1, tolerance = CF_Tube_OD_tolerance) {
|
|
d = CF_Tube_OD + tolerance;
|
|
taper_OD = (CF_Tube_OD*taper_mul) + tolerance;
|
|
l = CF_Tube_Len;
|
|
$fn = 90;
|
|
for (v = $reinforcing_tube_positions) {
|
|
y0 = v[1];
|
|
y1 = y0+l;
|
|
translate(v = v) rotate([-90, 0, 0]) cylinder_beak(d=d, h=l);
|
|
for (cut_y = $segment_cuts) {
|
|
if (cut_y == y0) {
|
|
// Taper in only (beginning of segment)
|
|
translate([v[0], cut_y, v[2]]) rotate([-90,0,0]) cylinder_outer(d=taper_OD, d2=d, h=taper_length);
|
|
} else if (cut_y == y1) {
|
|
// Taper out only (end of segment)
|
|
translate([v[0], cut_y, v[2]]) rotate([90,0,0]) cylinder_outer(d=taper_OD, d2=d, h=taper_length);
|
|
} else if ((y1 > cut_y) && (cut_y > y0)) {
|
|
// Taper in and out (tube spans multiple segments)
|
|
translate([v[0], cut_y, v[2]]) for (i=[-1,1]) rotate([i*90,0,0]) cylinder_outer(d=taper_OD, d2=d, h=taper_length);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
module Dowels() {
|
|
for (v = $dowel_positions) translate(v) Dowel();
|
|
}
|
|
module Reinforcements() {
|
|
TrussRods();
|
|
CFs();
|
|
Dowels();
|
|
}
|