Jerry
497 lines
16 KiB
Python
497 lines
16 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Bent-sheet end bracket for wrapping a 2020 extrusion end and two side faces.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import math
|
|
import os
|
|
import sys
|
|
from dataclasses import dataclass
|
|
from pathlib import Path
|
|
|
|
V1_DIR = Path(__file__).resolve().parents[1]
|
|
TOM_DIR = V1_DIR.parent
|
|
_CACHE_HOME = V1_DIR / ".cache"
|
|
_CACHE_HOME.mkdir(parents=True, exist_ok=True)
|
|
os.environ.setdefault("XDG_CACHE_HOME", str(_CACHE_HOME))
|
|
os.environ.setdefault("EZDXF_CACHE_HOME", str(_CACHE_HOME / "ezdxf"))
|
|
|
|
import build123d
|
|
import ezdxf
|
|
from ezdxf.units import MM as DXF_UNIT_MM
|
|
|
|
if str(TOM_DIR) not in sys.path:
|
|
sys.path.insert(0, str(TOM_DIR))
|
|
|
|
from robot_common.keyed_connection import (
|
|
KEYED_CONNECTION_HALF_SPAN_MM,
|
|
KEYED_CONNECTION_REF,
|
|
KEYED_CONNECTION_ROTATION_DEG,
|
|
make_keyed_connection_face,
|
|
sample_keyed_connection_outline,
|
|
)
|
|
|
|
|
|
PART_NAME = Path(__file__).stem
|
|
DISPLAY_NAME = "Extrusion Bracket 2020"
|
|
|
|
EXTRUSION_X_SPAN_MM = 20.0
|
|
EXTRUSION_X_HALF_SPAN_MM = 0.5 * EXTRUSION_X_SPAN_MM
|
|
EXTRUSION_Y_SPAN_MM = 20.0
|
|
EXTRUSION_Y_HALF_SPAN_MM = 0.5 * EXTRUSION_Y_SPAN_MM
|
|
# Keep the bracket seated tightly on the 2020 extrusion; any additional offset
|
|
# should come from a future face redesign rather than opening the full wrap gap.
|
|
EXTRUSION_CLEARANCE_MM = 0.5
|
|
SHORT_SIDE_MM = EXTRUSION_X_SPAN_MM
|
|
SHORT_SIDE_HALF_MM = 0.5 * SHORT_SIDE_MM
|
|
SHEET_THICKNESS_MM = 1.6
|
|
BRACKET_DEPTH_MM = 30.0
|
|
FREE_END_CORNER_RADIUS_MM = 1.0
|
|
M5_CLEARANCE_RADIUS_MM = 2.75
|
|
# Keep the inner row a bit farther off the bend die region for SendCutSend.
|
|
SIDE_FASTENER_Z_POSITIONS_MM = (10.0, 22.0)
|
|
CUT_EXTENSION_MM = 1.0
|
|
EDGE_MATCH_TOLERANCE_MM = 1e-3
|
|
|
|
SENDCUTSEND_EFFECTIVE_BEND_RADIUS_MM = 25.4 * 0.038
|
|
SENDCUTSEND_K_FACTOR = 0.48
|
|
SENDCUTSEND_BEND_DEDUCTION_90_MM = (
|
|
2.0 * (SENDCUTSEND_EFFECTIVE_BEND_RADIUS_MM + SHEET_THICKNESS_MM)
|
|
) - (
|
|
(math.pi * 0.5)
|
|
* (SENDCUTSEND_EFFECTIVE_BEND_RADIUS_MM + (SENDCUTSEND_K_FACTOR * SHEET_THICKNESS_MM))
|
|
)
|
|
SENDCUTSEND_MIN_FLANGE_FORMED_MM = 25.4 * 0.313
|
|
SENDCUTSEND_MIN_FLANGE_FLAT_MM = 25.4 * 0.255
|
|
SENDCUTSEND_HALF_DIE_WIDTH_MM = 0.5 * (25.4 * 0.472)
|
|
|
|
INNER_X_MIN = -(EXTRUSION_X_HALF_SPAN_MM + EXTRUSION_CLEARANCE_MM)
|
|
INNER_X_MAX = -INNER_X_MIN
|
|
INNER_Y_MIN = -(EXTRUSION_Y_HALF_SPAN_MM + EXTRUSION_CLEARANCE_MM)
|
|
INNER_Y_MAX = -INNER_Y_MIN
|
|
OUTER_X_MIN = -SHORT_SIDE_HALF_MM
|
|
OUTER_X_MAX = SHORT_SIDE_HALF_MM
|
|
|
|
BASE_Z_MIN = -SHEET_THICKNESS_MM
|
|
BASE_Z_MAX = 0.0
|
|
SIDE_Z_MIN = BASE_Z_MIN
|
|
SIDE_Z_MAX = BRACKET_DEPTH_MM
|
|
|
|
LOWER_Y_MIN = INNER_Y_MIN - SHEET_THICKNESS_MM
|
|
LOWER_Y_MAX = INNER_Y_MIN
|
|
UPPER_Y_MIN = INNER_Y_MAX
|
|
UPPER_Y_MAX = INNER_Y_MAX + SHEET_THICKNESS_MM
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class FlatPattern:
|
|
total_length_mm: float
|
|
width_mm: float
|
|
flange_flat_length_mm: float
|
|
web_flat_start_mm: float
|
|
web_flat_end_mm: float
|
|
bend_line_positions_mm: tuple[float, float]
|
|
cut_profile_centers: tuple[tuple[float, float], ...]
|
|
cut_circles: tuple[tuple[float, float, float], ...]
|
|
rounded_corner_radius_mm: float
|
|
min_feature_to_bend_mm: float
|
|
|
|
|
|
def _make_box(
|
|
*,
|
|
x_min: float,
|
|
x_max: float,
|
|
y_min: float,
|
|
y_max: float,
|
|
z_min: float,
|
|
z_max: float,
|
|
) -> build123d.Solid:
|
|
return build123d.Solid.make_box(
|
|
x_max - x_min,
|
|
y_max - y_min,
|
|
z_max - z_min,
|
|
plane=build123d.Plane(origin=build123d.Vector(x_min, y_min, z_min)),
|
|
)
|
|
|
|
|
|
def _make_cylinder_along(
|
|
*,
|
|
radius: float,
|
|
height: float,
|
|
origin: build123d.Vector,
|
|
direction: build123d.Vector,
|
|
) -> build123d.Solid:
|
|
return build123d.Solid.make_cylinder(
|
|
radius,
|
|
height,
|
|
plane=build123d.Plane(origin=origin, z_dir=direction),
|
|
)
|
|
|
|
|
|
def _make_keyed_connection_cutter_along_z(
|
|
*,
|
|
center_x: float,
|
|
center_y: float,
|
|
start_z: float,
|
|
height: float,
|
|
) -> build123d.Solid:
|
|
face = make_keyed_connection_face(
|
|
origin=build123d.Vector(center_x, center_y, start_z),
|
|
u_dir=build123d.Vector(1.0, 0.0, 0.0),
|
|
v_dir=build123d.Vector(0.0, 1.0, 0.0),
|
|
)
|
|
return build123d.Solid.extrude(face, build123d.Vector(0.0, 0.0, height))
|
|
|
|
|
|
def _sendcutsend_outside_setback_90_mm() -> float:
|
|
return SENDCUTSEND_EFFECTIVE_BEND_RADIUS_MM + SHEET_THICKNESS_MM
|
|
|
|
|
|
def _sendcutsend_bend_allowance_90_mm() -> float:
|
|
return (math.pi * 0.5) * (
|
|
SENDCUTSEND_EFFECTIVE_BEND_RADIUS_MM + (SENDCUTSEND_K_FACTOR * SHEET_THICKNESS_MM)
|
|
)
|
|
|
|
|
|
def _is_close(value: float, expected: float, tolerance: float = EDGE_MATCH_TOLERANCE_MM) -> bool:
|
|
return abs(value - expected) <= tolerance
|
|
|
|
|
|
def _validate_sendcutsend_bend_rule() -> None:
|
|
bend_deduction_error = abs(
|
|
SENDCUTSEND_BEND_DEDUCTION_90_MM
|
|
- ((2.0 * _sendcutsend_outside_setback_90_mm()) - _sendcutsend_bend_allowance_90_mm())
|
|
)
|
|
if bend_deduction_error > 0.05:
|
|
raise RuntimeError(
|
|
"SendCutSend bend-rule constants are inconsistent: "
|
|
f"bend deduction error {bend_deduction_error:.3f} mm is too large"
|
|
)
|
|
|
|
|
|
def build_bracket() -> build123d.Shape:
|
|
end_face = _make_box(
|
|
x_min=OUTER_X_MIN,
|
|
x_max=OUTER_X_MAX,
|
|
y_min=INNER_Y_MIN,
|
|
y_max=INNER_Y_MAX,
|
|
z_min=BASE_Z_MIN,
|
|
z_max=BASE_Z_MAX,
|
|
)
|
|
|
|
lower_flange = _make_box(
|
|
x_min=OUTER_X_MIN,
|
|
x_max=OUTER_X_MAX,
|
|
y_min=LOWER_Y_MIN,
|
|
y_max=LOWER_Y_MAX,
|
|
z_min=SIDE_Z_MIN,
|
|
z_max=SIDE_Z_MAX,
|
|
)
|
|
|
|
upper_flange = _make_box(
|
|
x_min=OUTER_X_MIN,
|
|
x_max=OUTER_X_MAX,
|
|
y_min=UPPER_Y_MIN,
|
|
y_max=UPPER_Y_MAX,
|
|
z_min=SIDE_Z_MIN,
|
|
z_max=SIDE_Z_MAX,
|
|
)
|
|
|
|
bracket = end_face.fuse(lower_flange).fuse(upper_flange)
|
|
|
|
hole_length = SHEET_THICKNESS_MM + (2.0 * CUT_EXTENSION_MM)
|
|
bracket = bracket.cut(
|
|
_make_keyed_connection_cutter_along_z(
|
|
center_x=0.0,
|
|
center_y=0.0,
|
|
start_z=BASE_Z_MIN - CUT_EXTENSION_MM,
|
|
height=hole_length,
|
|
)
|
|
)
|
|
|
|
for z_position in SIDE_FASTENER_Z_POSITIONS_MM:
|
|
bracket = bracket.cut(
|
|
_make_cylinder_along(
|
|
radius=M5_CLEARANCE_RADIUS_MM,
|
|
height=hole_length,
|
|
origin=build123d.Vector(0.0, LOWER_Y_MIN - CUT_EXTENSION_MM, z_position),
|
|
direction=build123d.Vector(0.0, 1.0, 0.0),
|
|
)
|
|
)
|
|
bracket = bracket.cut(
|
|
_make_cylinder_along(
|
|
radius=M5_CLEARANCE_RADIUS_MM,
|
|
height=hole_length,
|
|
origin=build123d.Vector(0.0, UPPER_Y_MAX + CUT_EXTENSION_MM, z_position),
|
|
direction=build123d.Vector(0.0, -1.0, 0.0),
|
|
)
|
|
)
|
|
|
|
target_edge_centers = (
|
|
build123d.Vector(
|
|
-SHORT_SIDE_HALF_MM,
|
|
LOWER_Y_MIN + (0.5 * SHEET_THICKNESS_MM),
|
|
BRACKET_DEPTH_MM,
|
|
),
|
|
build123d.Vector(
|
|
SHORT_SIDE_HALF_MM,
|
|
LOWER_Y_MIN + (0.5 * SHEET_THICKNESS_MM),
|
|
BRACKET_DEPTH_MM,
|
|
),
|
|
build123d.Vector(
|
|
-SHORT_SIDE_HALF_MM,
|
|
UPPER_Y_MAX - (0.5 * SHEET_THICKNESS_MM),
|
|
BRACKET_DEPTH_MM,
|
|
),
|
|
build123d.Vector(
|
|
SHORT_SIDE_HALF_MM,
|
|
UPPER_Y_MAX - (0.5 * SHEET_THICKNESS_MM),
|
|
BRACKET_DEPTH_MM,
|
|
),
|
|
)
|
|
target_edges: list[build123d.Edge] = []
|
|
for edge in bracket.edges():
|
|
if edge.geom_type != build123d.GeomType.LINE:
|
|
continue
|
|
center = edge.center()
|
|
if any(
|
|
_is_close(center.X, target_center.X)
|
|
and _is_close(center.Y, target_center.Y)
|
|
and _is_close(center.Z, target_center.Z)
|
|
for target_center in target_edge_centers
|
|
):
|
|
target_edges.append(edge)
|
|
|
|
if len(target_edges) != len(target_edge_centers):
|
|
raise RuntimeError(
|
|
"Expected to find the four flange free-end corners for rounding, "
|
|
f"found {len(target_edges)}"
|
|
)
|
|
|
|
bracket = build123d.fillet(target_edges, FREE_END_CORNER_RADIUS_MM)
|
|
|
|
solids = list(bracket.solids())
|
|
if len(solids) != 1:
|
|
raise RuntimeError(f"Expected one wrap bracket solid, found {len(solids)}")
|
|
|
|
bracket = solids[0]
|
|
bracket.label = PART_NAME
|
|
|
|
bbox = bracket.bounding_box()
|
|
print(
|
|
"Bent-sheet 2020 end bracket: "
|
|
f"clearance={EXTRUSION_CLEARANCE_MM:.3f} mm, "
|
|
f"thickness={SHEET_THICKNESS_MM:.3f} mm, "
|
|
f"depth={BRACKET_DEPTH_MM:.3f} mm, "
|
|
f"free_corner_radius={FREE_END_CORNER_RADIUS_MM:.3f} mm, "
|
|
f"size=({bbox.size.X:.3f}, {bbox.size.Y:.3f}, {bbox.size.Z:.3f}) mm, "
|
|
f"plate_fasteners={2 * len(SIDE_FASTENER_Z_POSITIONS_MM)}, "
|
|
f"connection_ref={KEYED_CONNECTION_REF}, "
|
|
f"connection_rotation={KEYED_CONNECTION_ROTATION_DEG:.1f} deg, "
|
|
f"hole_diameter={2.0 * M5_CLEARANCE_RADIUS_MM:.3f} mm"
|
|
)
|
|
return bracket
|
|
|
|
|
|
def _build_flat_pattern() -> FlatPattern:
|
|
_validate_sendcutsend_bend_rule()
|
|
|
|
outside_setback = _sendcutsend_outside_setback_90_mm()
|
|
bend_allowance = _sendcutsend_bend_allowance_90_mm()
|
|
flange_outside_length = BRACKET_DEPTH_MM + SHEET_THICKNESS_MM
|
|
flange_flat_length = flange_outside_length - outside_setback
|
|
if flange_outside_length < SENDCUTSEND_MIN_FLANGE_FORMED_MM:
|
|
raise RuntimeError(
|
|
"Formed flange length is below the configured bend-rule minimum: "
|
|
f"{flange_outside_length:.3f} mm < {SENDCUTSEND_MIN_FLANGE_FORMED_MM:.3f} mm"
|
|
)
|
|
if flange_flat_length < SENDCUTSEND_MIN_FLANGE_FLAT_MM:
|
|
raise RuntimeError(
|
|
"Flat flange length is below the configured bend-rule minimum: "
|
|
f"{flange_flat_length:.3f} mm < {SENDCUTSEND_MIN_FLANGE_FLAT_MM:.3f} mm"
|
|
)
|
|
|
|
web_outside_length = INNER_Y_MAX - INNER_Y_MIN
|
|
web_flat_length = web_outside_length - (2.0 * SENDCUTSEND_EFFECTIVE_BEND_RADIUS_MM)
|
|
if web_flat_length <= 0.0:
|
|
raise RuntimeError(f"Web flat length implied by the bend rule is too short: {web_flat_length:.3f} mm")
|
|
|
|
web_flat_start = flange_flat_length + bend_allowance
|
|
web_flat_end = web_flat_start + web_flat_length
|
|
total_length = web_flat_end + bend_allowance + flange_flat_length
|
|
width = OUTER_X_MAX - OUTER_X_MIN
|
|
bend_line_positions = (
|
|
flange_flat_length + (0.5 * bend_allowance),
|
|
web_flat_end + (0.5 * bend_allowance),
|
|
)
|
|
|
|
def _v_from_x(x_coord: float) -> float:
|
|
return x_coord - OUTER_X_MIN
|
|
|
|
keyed_connection_center_u = web_flat_start + (-INNER_Y_MIN - SENDCUTSEND_EFFECTIVE_BEND_RADIUS_MM)
|
|
cut_profile_centers = ((keyed_connection_center_u, _v_from_x(0.0)),)
|
|
cut_circles: list[tuple[float, float, float]] = []
|
|
for z_position in SIDE_FASTENER_Z_POSITIONS_MM:
|
|
lower_u = BRACKET_DEPTH_MM - z_position
|
|
upper_u = total_length - (BRACKET_DEPTH_MM - z_position)
|
|
cut_circles.append((lower_u, _v_from_x(0.0), M5_CLEARANCE_RADIUS_MM))
|
|
cut_circles.append((upper_u, _v_from_x(0.0), M5_CLEARANCE_RADIUS_MM))
|
|
|
|
min_feature_to_bend = min(
|
|
abs(keyed_connection_center_u - bend_u) - KEYED_CONNECTION_HALF_SPAN_MM
|
|
for bend_u in bend_line_positions
|
|
)
|
|
min_feature_to_bend = min(
|
|
min_feature_to_bend,
|
|
min(
|
|
abs(center_u - bend_u) - radius
|
|
for center_u, _center_v, radius in cut_circles
|
|
for bend_u in bend_line_positions
|
|
),
|
|
)
|
|
return FlatPattern(
|
|
total_length_mm=total_length,
|
|
width_mm=width,
|
|
flange_flat_length_mm=flange_flat_length,
|
|
web_flat_start_mm=web_flat_start,
|
|
web_flat_end_mm=web_flat_end,
|
|
bend_line_positions_mm=bend_line_positions,
|
|
cut_profile_centers=cut_profile_centers,
|
|
cut_circles=tuple(cut_circles),
|
|
rounded_corner_radius_mm=FREE_END_CORNER_RADIUS_MM,
|
|
min_feature_to_bend_mm=min_feature_to_bend,
|
|
)
|
|
|
|
|
|
def build_dxf() -> ezdxf.document.Drawing:
|
|
flat_pattern = _build_flat_pattern()
|
|
|
|
doc = ezdxf.new("R2010", setup=True)
|
|
doc.units = DXF_UNIT_MM
|
|
if "CUT" not in doc.layers:
|
|
doc.layers.add("CUT")
|
|
if "BEND" not in doc.layers:
|
|
doc.layers.add("BEND", linetype="DASHED")
|
|
|
|
msp = doc.modelspace()
|
|
corner_radius = flat_pattern.rounded_corner_radius_mm
|
|
if corner_radius <= 0.0:
|
|
outline = (
|
|
(0.0, 0.0),
|
|
(flat_pattern.total_length_mm, 0.0),
|
|
(flat_pattern.total_length_mm, flat_pattern.width_mm),
|
|
(0.0, flat_pattern.width_mm),
|
|
)
|
|
msp.add_lwpolyline(outline, format="xy", close=True, dxfattribs={"layer": "CUT"})
|
|
else:
|
|
if (2.0 * corner_radius) >= flat_pattern.width_mm:
|
|
raise RuntimeError(
|
|
"Rounded flange corners exceed the flat-pattern width: "
|
|
f"diameter {2.0 * corner_radius:.3f} mm >= width {flat_pattern.width_mm:.3f} mm"
|
|
)
|
|
msp.add_line(
|
|
(corner_radius, 0.0),
|
|
(flat_pattern.total_length_mm - corner_radius, 0.0),
|
|
dxfattribs={"layer": "CUT"},
|
|
)
|
|
msp.add_arc(
|
|
(corner_radius, corner_radius),
|
|
corner_radius,
|
|
180.0,
|
|
270.0,
|
|
dxfattribs={"layer": "CUT"},
|
|
)
|
|
msp.add_arc(
|
|
(flat_pattern.total_length_mm - corner_radius, corner_radius),
|
|
corner_radius,
|
|
270.0,
|
|
360.0,
|
|
dxfattribs={"layer": "CUT"},
|
|
)
|
|
msp.add_line(
|
|
(flat_pattern.total_length_mm, corner_radius),
|
|
(flat_pattern.total_length_mm, flat_pattern.width_mm - corner_radius),
|
|
dxfattribs={"layer": "CUT"},
|
|
)
|
|
msp.add_arc(
|
|
(flat_pattern.total_length_mm - corner_radius, flat_pattern.width_mm - corner_radius),
|
|
corner_radius,
|
|
0.0,
|
|
90.0,
|
|
dxfattribs={"layer": "CUT"},
|
|
)
|
|
msp.add_line(
|
|
(flat_pattern.total_length_mm - corner_radius, flat_pattern.width_mm),
|
|
(corner_radius, flat_pattern.width_mm),
|
|
dxfattribs={"layer": "CUT"},
|
|
)
|
|
msp.add_arc(
|
|
(corner_radius, flat_pattern.width_mm - corner_radius),
|
|
corner_radius,
|
|
90.0,
|
|
180.0,
|
|
dxfattribs={"layer": "CUT"},
|
|
)
|
|
msp.add_line(
|
|
(0.0, flat_pattern.width_mm - corner_radius),
|
|
(0.0, corner_radius),
|
|
dxfattribs={"layer": "CUT"},
|
|
)
|
|
|
|
for center_u, center_v, radius in flat_pattern.cut_circles:
|
|
msp.add_circle((center_u, center_v), radius, dxfattribs={"layer": "CUT"})
|
|
for center_u, center_v in flat_pattern.cut_profile_centers:
|
|
msp.add_lwpolyline(
|
|
sample_keyed_connection_outline(center_u=center_u, center_v=center_v, points_per_arc=16),
|
|
format="xy",
|
|
close=True,
|
|
dxfattribs={"layer": "CUT"},
|
|
)
|
|
|
|
for bend_line_u in flat_pattern.bend_line_positions_mm:
|
|
msp.add_line(
|
|
(bend_line_u, 0.0),
|
|
(bend_line_u, flat_pattern.width_mm),
|
|
dxfattribs={"layer": "BEND", "linetype": "DASHED"},
|
|
)
|
|
|
|
print(
|
|
"Flat pattern "
|
|
f"length={flat_pattern.total_length_mm:.3f} mm, "
|
|
f"width={flat_pattern.width_mm:.3f} mm, "
|
|
f"bend_lines=({flat_pattern.bend_line_positions_mm[0]:.3f}, {flat_pattern.bend_line_positions_mm[1]:.3f}) mm, "
|
|
f"cut_profiles={len(flat_pattern.cut_profile_centers)}, "
|
|
f"cut_circles={len(flat_pattern.cut_circles)}"
|
|
)
|
|
print(
|
|
"DXF bend checks "
|
|
f"flange_flat={flat_pattern.flange_flat_length_mm:.3f} mm, "
|
|
f"flange_flat_required={SENDCUTSEND_MIN_FLANGE_FLAT_MM:.3f} mm, "
|
|
f"feature_to_bend_min={flat_pattern.min_feature_to_bend_mm:.3f} mm, "
|
|
f"feature_to_bend_required={SENDCUTSEND_HALF_DIE_WIDTH_MM:.3f} mm"
|
|
)
|
|
if flat_pattern.min_feature_to_bend_mm < SENDCUTSEND_HALF_DIE_WIDTH_MM:
|
|
print(
|
|
"Warning: flat-pattern keyed feature enters the bend die region by "
|
|
f"{SENDCUTSEND_HALF_DIE_WIDTH_MM - flat_pattern.min_feature_to_bend_mm:.3f} mm"
|
|
)
|
|
return doc
|
|
|
|
|
|
def gen_step() -> dict[str, object]:
|
|
return {
|
|
"shape": build_bracket(),
|
|
}
|
|
|
|
|
|
def gen_dxf() -> dict[str, object]:
|
|
return {
|
|
"document": build_dxf(),
|
|
}
|
|
|
|
|
|
if __name__ == "__main__":
|
|
gen_step()
|