Jerry
302 lines
9.8 KiB
Python
302 lines
9.8 KiB
Python
"""lyra palm: wrist flange, carpal core, palm slab, knuckle row, thumb turret.
|
|
|
|
Local frame = robot root frame: origin at the wrist-flange mount face
|
|
center, +Z distal, +Y palmar, +X radial. The palm owns all MCP clevis
|
|
cheeks, knuckle pins, the thumb CMC turret pedestal/spindle, and the
|
|
tactile palm pad.
|
|
|
|
Articulation clearances baked into the shape:
|
|
- Knuckle slots are open from y -14 to +15 so proximal phalanges sweep
|
|
-15..+95 deg without touching the covers.
|
|
- The palmar plate's top edge stays >= 8 mm proximal of each MCP axis,
|
|
outside the swept envelope of the flexing proximal shaft.
|
|
- A 15 mm radius relief is turned around the thumb turret so the yawing
|
|
thumb base clevis never clips the radial palm corner.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from build123d import (
|
|
Axis,
|
|
Box,
|
|
Plane,
|
|
Polyline,
|
|
Pos,
|
|
Rot,
|
|
RectangleRounded,
|
|
extrude,
|
|
loft,
|
|
make_face,
|
|
)
|
|
|
|
from .chain import FINGERS, MCP_ORIGIN_MM, THUMB_CMC_ORIGIN_MM
|
|
from .digits import (
|
|
FINGER_SCALE,
|
|
MCP_PIN_R,
|
|
PALM_LOBE_R,
|
|
PROX_TANG_W,
|
|
TB_TANG_R,
|
|
TB_TANG_H,
|
|
)
|
|
from .lib import (
|
|
ALU_COLOR,
|
|
AMBER_COLOR,
|
|
GRAPHITE_COLOR,
|
|
PAD_COLOR,
|
|
PEARL_COLOR,
|
|
SENSOR_COLOR,
|
|
part_compound,
|
|
pin,
|
|
safe_chamfer,
|
|
safe_fillet,
|
|
styled,
|
|
xcyl,
|
|
ycyl,
|
|
zcyl,
|
|
)
|
|
|
|
SLAB_HALF_Y = 9.5 # graphite core half-depth
|
|
COVER_Y0, COVER_Y1 = -12.1, -9.5 # pearl dorsal cover
|
|
PLATE_Y0, PLATE_Y1 = 9.5, 11.5 # pearl palmar plate
|
|
MCP_PIN_LEN = 17.0
|
|
|
|
# Thumb turret (axis +Z through chain.THUMB_CMC_ORIGIN_MM).
|
|
TURRET_R = 10.5
|
|
TURRET_RELIEF_R = 15.0
|
|
SPINDLE_R = 2.7
|
|
|
|
CX, CY, CZ = THUMB_CMC_ORIGIN_MM
|
|
|
|
# Palm silhouette in the XZ plane (clockwise; +X radial, +Z distal). The
|
|
# knuckle arch follows the MCP line (index 99 / middle 103 / ring 99 /
|
|
# pinky 90); lobes added per knuckle crown above it.
|
|
CORE_PTS = [
|
|
(-25.0, 33.0), (-33.0, 50.0), (-36.5, 72.0), (-36.5, 87.0),
|
|
(-30.0, 90.0), (-19.0, 95.0), (-9.5, 99.0), (0.0, 101.0),
|
|
(9.5, 103.0), (19.0, 101.0), (28.5, 99.0), (34.0, 97.5),
|
|
(37.5, 95.5), (37.5, 70.0), (30.0, 46.0), (25.0, 33.0),
|
|
]
|
|
COVER_PTS = [
|
|
(-23.5, 35.0), (-31.3, 51.0), (-34.8, 72.0), (-34.8, 85.6),
|
|
(-29.0, 88.4), (-18.6, 93.0), (-9.5, 97.0), (0.0, 99.0),
|
|
(9.5, 101.0), (18.6, 99.0), (28.5, 97.0), (33.0, 95.6),
|
|
(35.8, 93.8), (35.8, 71.0), (28.6, 47.5), (23.4, 35.0),
|
|
]
|
|
PLATE_PTS = [
|
|
(-23.5, 35.0), (-31.0, 51.0), (-34.5, 72.0), (-34.5, 80.0),
|
|
(-28.6, 82.5), (-18.6, 86.0), (-9.5, 91.0), (0.0, 93.0),
|
|
(9.5, 95.0), (19.0, 93.0), (28.5, 91.0), (35.5, 87.5),
|
|
(35.5, 71.0), (28.6, 47.5), (23.4, 35.0),
|
|
]
|
|
|
|
|
|
def _outline_solid(pts, y0, depth):
|
|
pts3 = [(x, y0, z) for x, z in pts]
|
|
face = make_face(Polyline(*pts3, close=True))
|
|
return extrude(face, amount=depth, dir=(0, 1, 0))
|
|
|
|
|
|
def _slot_gap(finger: str) -> float:
|
|
return PROX_TANG_W * FINGER_SCALE[finger] + 0.7
|
|
|
|
|
|
def _knuckle_cuts(solid):
|
|
"""Open the four MCP clevis slots and pin bores in a palm solid."""
|
|
for finger in FINGERS:
|
|
kx, _, kz = MCP_ORIGIN_MM[finger]
|
|
gap = _slot_gap(finger)
|
|
solid -= Pos(kx, 0.5, kz + 2.0) * Box(gap, 29.0, 26.0)
|
|
solid -= Pos(kx, 0, kz) * xcyl(MCP_PIN_R + 0.4, 26.0)
|
|
return solid
|
|
|
|
|
|
def _thumb_relief(solid):
|
|
"""Turned clearance around the thumb turret for the yawing base clevis."""
|
|
disc_z0 = CZ - TB_TANG_H / 2.0
|
|
return solid - Pos(CX, CY, disc_z0 + 5.6) * zcyl(TURRET_RELIEF_R, 11.6)
|
|
|
|
|
|
def _wrist_flange():
|
|
flange = Pos(0, 0, 3.0) * zcyl(23.0, 6.0)
|
|
flange = safe_chamfer(flange, flange.edges(), 1.2)
|
|
heads = []
|
|
for i in range(6):
|
|
from math import cos, pi, sin
|
|
|
|
a = 2.0 * pi * i / 6.0
|
|
bx, by = 16.5 * cos(a), 16.5 * sin(a)
|
|
flange -= Pos(bx, by, 1.5) * zcyl(3.6, 3.0)
|
|
flange -= Pos(bx, by, 3.0) * zcyl(2.3, 8.0)
|
|
head = Pos(bx, by, 1.4) * zcyl(3.3, 2.2)
|
|
head = safe_chamfer(head, head.edges(), 0.5)
|
|
heads.append(styled(head, f"flange_bolt_{i}", GRAPHITE_COLOR))
|
|
return styled(flange, "wrist_flange", ALU_COLOR), heads
|
|
|
|
|
|
def _carpal_core():
|
|
try:
|
|
f1 = Plane.XY.offset(6.0) * RectangleRounded(40.0, 17.5, 7.0)
|
|
f2 = Plane.XY.offset(33.0) * RectangleRounded(50.0, 19.0, 8.0)
|
|
carpal = loft([f1, f2])
|
|
except Exception:
|
|
carpal = Pos(0, 0, 19.5) * Box(46.0, 18.2, 27.0)
|
|
carpal = safe_fillet(carpal, carpal.edges().filter_by(Axis.Z), 7.0)
|
|
return styled(carpal, "carpal_core", GRAPHITE_COLOR)
|
|
|
|
|
|
def _palm_core():
|
|
core = _outline_solid(CORE_PTS, -SLAB_HALF_Y, 2 * SLAB_HALF_Y)
|
|
core = safe_fillet(core, core.edges().filter_by(Axis.Y), 2.2)
|
|
|
|
# Knuckle lobe crowns (cut by the clevis slots into cheek arcs).
|
|
for finger in FINGERS:
|
|
kx, _, kz = MCP_ORIGIN_MM[finger]
|
|
s = FINGER_SCALE[finger]
|
|
core += Pos(kx, 0, kz) * xcyl(PALM_LOBE_R * s, _slot_gap(finger) + 7.0)
|
|
|
|
# Thumb turret pedestal (bored for the spindle), merged into the
|
|
# radial-palmar corner.
|
|
disc_z0 = CZ - TB_TANG_H / 2.0
|
|
pedestal = Pos(CX, CY, disc_z0 - 3.4) * (zcyl(TURRET_R, 6.4) - zcyl(SPINDLE_R + 0.7, 9.0))
|
|
pedestal = safe_chamfer(pedestal, pedestal.edges(), 1.0)
|
|
core += pedestal
|
|
|
|
core = _knuckle_cuts(core)
|
|
core = _thumb_relief(core)
|
|
return styled(core, "palm_core", GRAPHITE_COLOR)
|
|
|
|
|
|
def _dorsal_cover():
|
|
cover = _outline_solid(COVER_PTS, COVER_Y0, COVER_Y1 - COVER_Y0)
|
|
cover = safe_fillet(cover, cover.edges().filter_by(Axis.Y), 2.0)
|
|
try:
|
|
outer = cover.faces().sort_by(Axis.Y)[0]
|
|
cover = safe_chamfer(cover, outer.edges(), 1.0)
|
|
except Exception:
|
|
pass
|
|
# Engraved tendon-channel lines running from the carpal exit to each
|
|
# knuckle slot (clean covered cable routing, shown as shadow grooves).
|
|
from math import atan2, degrees, hypot
|
|
|
|
for finger in FINGERS:
|
|
kx, _, kz = MCP_ORIGIN_MM[finger]
|
|
ax, az = kx * 0.42, 40.0
|
|
bx, bz = kx, kz - 12.0
|
|
mx, mz = (ax + bx) / 2.0, (az + bz) / 2.0
|
|
ang = degrees(atan2(bx - ax, bz - az))
|
|
glen = hypot(bx - ax, bz - az)
|
|
groove = Pos(mx, COVER_Y0 + 0.25, mz) * Rot(0, ang, 0) * Box(1.6, 1.0, glen)
|
|
try:
|
|
cover -= groove
|
|
except Exception:
|
|
pass
|
|
cover = _knuckle_cuts(cover)
|
|
cover = _thumb_relief(cover)
|
|
return styled(cover, "dorsal_cover", PEARL_COLOR)
|
|
|
|
|
|
def _palmar_plate():
|
|
plate = _outline_solid(PLATE_PTS, PLATE_Y0, PLATE_Y1 - PLATE_Y0)
|
|
plate = safe_fillet(plate, plate.edges().filter_by(Axis.Y), 2.0)
|
|
try:
|
|
outer = plate.faces().sort_by(Axis.Y)[-1]
|
|
plate = safe_chamfer(plate, outer.edges(), 0.8)
|
|
except Exception:
|
|
pass
|
|
# Pocket for the tactile pad (pad sits 0.4 into the plate).
|
|
plate -= Pos(0, PLATE_Y1, 65.0) * Box(46.4, 2.0, 30.4)
|
|
plate = _knuckle_cuts(plate)
|
|
plate = _thumb_relief(plate)
|
|
return styled(plate, "palmar_plate", PEARL_COLOR)
|
|
|
|
|
|
def _palm_pad():
|
|
pad = Pos(0, PLATE_Y1 - 0.4 + 0.85, 65.0) * Box(46.0, 1.7, 30.0)
|
|
pad = safe_fillet(pad, pad.edges().filter_by(Axis.Y), 5.0)
|
|
# Tactile zone split grooves (2 x 2 sensor array read as fine lines).
|
|
for cut in (
|
|
Pos(0, PLATE_Y1 + 1.3, 65.0) * Box(1.2, 1.0, 30.5),
|
|
Pos(0, PLATE_Y1 + 1.3, 65.0) * Box(46.5, 1.0, 1.2),
|
|
):
|
|
try:
|
|
pad -= cut
|
|
except Exception:
|
|
pass
|
|
pad = _thumb_relief(pad)
|
|
return styled(pad, "palm_pad", PAD_COLOR)
|
|
|
|
|
|
def _palm_sensor():
|
|
ring = Pos(0, PLATE_Y1 + 0.3, 87.0) * (ycyl(5.0, 0.6) - ycyl(4.0, 3.0))
|
|
lens = Pos(0, PLATE_Y1 + 0.2, 87.0) * ycyl(3.9, 0.8)
|
|
return [
|
|
styled(ring, "palm_sensor_ring", AMBER_COLOR),
|
|
styled(lens, "palm_sensor_lens", SENSOR_COLOR),
|
|
]
|
|
|
|
|
|
def _tensioners():
|
|
"""Tendon tensioner dial row on the dorsal carpal face."""
|
|
out = []
|
|
for i, dx in enumerate((-12.0, -6.0, 0.0, 6.0, 12.0)):
|
|
face_y = -(8.75 + 0.75 * (20.0 - 6.0) / 27.0)
|
|
dial = Pos(dx, face_y - 1.1, 20.0) * ycyl(2.6, 2.4)
|
|
dial = safe_chamfer(dial, dial.edges(), 0.5)
|
|
out.append(styled(dial, f"tensioner_dial_{i}", ALU_COLOR))
|
|
dot = Pos(dx, face_y - 2.5, 20.0) * ycyl(1.0, 0.7)
|
|
out.append(styled(dot, f"tensioner_dot_{i}", AMBER_COLOR))
|
|
return out
|
|
|
|
|
|
def _knuckle_hardware():
|
|
"""Palm-owned MCP pins plus rim washers on the outer index/pinky cheeks."""
|
|
out = []
|
|
for finger in FINGERS:
|
|
kx, _, kz = MCP_ORIGIN_MM[finger]
|
|
out.append(
|
|
styled(
|
|
Pos(kx, 0, kz) * pin("x", MCP_PIN_R, MCP_PIN_LEN),
|
|
f"{finger}_mcp_pin",
|
|
ALU_COLOR,
|
|
)
|
|
)
|
|
for finger, xr in (("index", 38.2), ("pinky", -37.2)):
|
|
kx, _, kz = MCP_ORIGIN_MM[finger]
|
|
rim = Pos(xr, 0, kz) * (xcyl(4.6, 1.2) - xcyl(MCP_PIN_R + 0.4, 3.0))
|
|
out.append(styled(rim, f"{finger}_mcp_rim", ALU_COLOR))
|
|
return out
|
|
|
|
|
|
def _turret_hardware():
|
|
"""Bearing collar + spindle/cap for the thumb CMC turret (palm side)."""
|
|
disc_z0 = CZ - TB_TANG_H / 2.0
|
|
disc_z1 = CZ + TB_TANG_H / 2.0
|
|
collar = Pos(CX, CY, disc_z0 - 0.95) * (zcyl(TURRET_R + 0.7, 1.5) - zcyl(TB_TANG_R + 0.8, 3.0))
|
|
collar = safe_chamfer(collar, collar.edges(), 0.4)
|
|
spindle = Pos(CX, CY, (disc_z0 - 5.0 + disc_z1 + 0.4) / 2.0) * zcyl(
|
|
SPINDLE_R, disc_z1 + 0.4 - (disc_z0 - 5.0)
|
|
)
|
|
cap = Pos(CX, CY, disc_z1 + 0.4 + 0.8) * zcyl(4.8, 1.6)
|
|
cap = safe_chamfer(cap, cap.edges(), 0.5)
|
|
spindle += cap
|
|
return [
|
|
styled(collar, "thumb_turret_collar", ALU_COLOR),
|
|
styled(spindle, "thumb_turret_spindle", ALU_COLOR),
|
|
]
|
|
|
|
|
|
def build_palm():
|
|
flange, bolt_heads = _wrist_flange()
|
|
solids = [flange]
|
|
solids += bolt_heads
|
|
solids.append(_carpal_core())
|
|
solids.append(_palm_core())
|
|
solids.append(_dorsal_cover())
|
|
solids.append(_palmar_plate())
|
|
solids.append(_palm_pad())
|
|
solids += _palm_sensor()
|
|
solids += _tensioners()
|
|
solids += _knuckle_hardware()
|
|
solids += _turret_hardware()
|
|
return part_compound("palm", solids)
|