980 lines
34 KiB
Python
980 lines
34 KiB
Python
"""
|
|
This file describes the shapes of the wing shells. The joints are defined in
|
|
`__init__.py`.
|
|
"""
|
|
import math
|
|
from enum import Enum
|
|
from dataclasses import dataclass, field
|
|
from typing import Mapping, Tuple, Optional
|
|
import cadquery as Cq
|
|
from nhf import Material, Role
|
|
from nhf.build import Model, TargetKind, target, assembly, submodel
|
|
from nhf.parts.box import box_with_centre_holes, MountingBox, Hole
|
|
from nhf.parts.joints import HirthJoint
|
|
from nhf.touhou.houjuu_nue.joints import ShoulderJoint, ElbowJoint, DiskJoint
|
|
import nhf.utils
|
|
|
|
@dataclass(kw_only=True)
|
|
class WingProfile(Model):
|
|
|
|
name: str = "wing"
|
|
|
|
base_joint: HirthJoint = field(default_factory=lambda: HirthJoint(
|
|
radius=25.0,
|
|
radius_inner=15.0,
|
|
tooth_height=7.0,
|
|
base_height=5,
|
|
n_tooth=24,
|
|
))
|
|
base_width: float = 80.0
|
|
hs_joint_corner_dx: float = 17.0
|
|
hs_joint_corner_dz: float = 24.0
|
|
hs_joint_corner_hole_diam: float = 6.0
|
|
hs_joint_axis_diam: float = 12.0
|
|
base_plate_width: float = 50.0
|
|
|
|
panel_thickness: float = 25.4 / 16
|
|
spacer_thickness: float = 25.4 / 8
|
|
|
|
shoulder_joint: ShoulderJoint = field(default_factory=lambda: ShoulderJoint(
|
|
))
|
|
shoulder_width: float = 36.0
|
|
shoulder_tip_x: float = -200.0
|
|
shoulder_tip_y: float = 160.0
|
|
shoulder_mid_x: float = -105.0
|
|
shoulder_mid_y: float = 75.0
|
|
|
|
s1_thickness: float = 25.0
|
|
|
|
elbow_joint: ElbowJoint = field(default_factory=lambda: ElbowJoint(
|
|
disk_joint=DiskJoint(
|
|
movement_angle=55,
|
|
),
|
|
))
|
|
# Distance between the two spacers on the elbow, halved
|
|
elbow_h2: float = 5.0
|
|
|
|
s2_thickness: float = 25.0
|
|
|
|
wrist_joint: ElbowJoint = field(default_factory=lambda: ElbowJoint(
|
|
disk_joint=DiskJoint(
|
|
movement_angle=45,
|
|
radius_disk=13.0,
|
|
radius_housing=15.0,
|
|
),
|
|
child_arm_radius=20.0,
|
|
parent_arm_radius=30.0,
|
|
))
|
|
# Distance between the two spacers on the elbow, halved
|
|
wrist_h2: float = 5.0
|
|
|
|
s3_thickness: float = 25.0
|
|
|
|
mat_panel: Material = Material.ACRYLIC_TRANSLUSCENT
|
|
mat_bracket: Material = Material.ACRYLIC_TRANSPARENT
|
|
mat_hs_joint: Material = Material.PLASTIC_PLA
|
|
role_panel: Role = Role.STRUCTURE
|
|
|
|
# Subclass must populate
|
|
elbow_x: float
|
|
elbow_y: float
|
|
elbow_angle: float
|
|
elbow_height: float
|
|
wrist_x: float
|
|
wrist_y: float
|
|
wrist_angle: float
|
|
wrist_height: float
|
|
|
|
flip: bool = False
|
|
|
|
def __post_init__(self):
|
|
super().__init__(name=self.name)
|
|
|
|
self.elbow_theta = math.radians(self.elbow_angle)
|
|
self.elbow_c = math.cos(self.elbow_theta)
|
|
self.elbow_s = math.sin(self.elbow_theta)
|
|
self.elbow_top_x, self.elbow_top_y = self.elbow_to_abs(0, self.elbow_height)
|
|
self.wrist_theta = math.radians(self.wrist_angle)
|
|
self.wrist_c = math.cos(self.wrist_theta)
|
|
self.wrist_s = math.sin(self.wrist_theta)
|
|
self.wrist_top_x, self.wrist_top_y = self.wrist_to_abs(0, self.wrist_height)
|
|
|
|
self.shoulder_joint.angle_neutral = -self.shoulder_angle_neutral
|
|
|
|
@submodel(name="shoulder-joint")
|
|
def submodel_shoulder_joint(self) -> Model:
|
|
return self.shoulder_joint
|
|
@submodel(name="elbow-joint")
|
|
def submodel_elbow_joint(self) -> Model:
|
|
return self.elbow_joint
|
|
@submodel(name="wrist-joint")
|
|
def submodel_wrist_joint(self) -> Model:
|
|
return self.wrist_joint
|
|
|
|
@property
|
|
def root_height(self) -> float:
|
|
return self.shoulder_joint.height
|
|
|
|
@property
|
|
def shoulder_height(self) -> float:
|
|
return self.shoulder_joint.height
|
|
|
|
@target(name="base-hs-joint")
|
|
def base_hs_joint(self) -> Cq.Workplane:
|
|
"""
|
|
Parent part of the Houjuu-Scarlett joint, which is composed of a Hirth
|
|
coupling, a cylindrical base, and a mounting base.
|
|
"""
|
|
hirth = self.base_joint.generate(is_mated=True)
|
|
dy = self.hs_joint_corner_dx
|
|
dx = self.hs_joint_corner_dz
|
|
conn = [
|
|
(-dx, -dy),
|
|
(dx, -dy),
|
|
(dx, dy),
|
|
(-dx, dy),
|
|
]
|
|
result = (
|
|
Cq.Workplane('XY')
|
|
.box(
|
|
self.root_height,
|
|
self.base_plate_width,
|
|
self.base_joint.base_height,
|
|
centered=(True, True, False))
|
|
#.translate((0, 0, -self.base_joint.base_height))
|
|
#.edges("|Z")
|
|
#.fillet(self.hs_joint_corner_fillet)
|
|
.faces(">Z")
|
|
.workplane()
|
|
.pushPoints(conn)
|
|
.hole(self.hs_joint_corner_hole_diam)
|
|
)
|
|
# Creates a plane parallel to the holes but shifted to the base
|
|
plane = result.faces(">Z").workplane(offset=-self.base_joint.base_height)
|
|
|
|
for i, (px, py) in enumerate(conn):
|
|
plane.moveTo(px, py).tagPlane(f"conn{i}")
|
|
result = (
|
|
result
|
|
.faces(">Z")
|
|
.workplane()
|
|
.union(hirth, tol=0.1)
|
|
.clean()
|
|
)
|
|
result = (
|
|
result.faces("<Z")
|
|
.workplane()
|
|
.hole(self.hs_joint_axis_diam)
|
|
)
|
|
return result
|
|
|
|
def outer_profile_s0(self) -> Cq.Sketch:
|
|
"""
|
|
The outer boundary of s0, used to produce the curved panel and the
|
|
top/bottom slots
|
|
"""
|
|
tip_x = self.shoulder_tip_x
|
|
tip_y = self.shoulder_tip_y
|
|
return (
|
|
Cq.Sketch()
|
|
.spline([
|
|
(0, 0),
|
|
(-30.0, 80.0),
|
|
(tip_x, tip_y)
|
|
])
|
|
#.segment(
|
|
# (tip_x, tip_y),
|
|
# (tip_x - 10, tip_y),
|
|
#)
|
|
)
|
|
|
|
@property
|
|
def shoulder_angle_neutral(self) -> float:
|
|
"""
|
|
Returns the neutral angle of the shoulder
|
|
"""
|
|
dx = self.shoulder_mid_x - self.shoulder_tip_x
|
|
dy = -(self.shoulder_mid_y - (self.shoulder_tip_y - self.shoulder_width))
|
|
result = math.degrees(math.atan2(dy, dx))
|
|
assert result >= 0
|
|
return result
|
|
|
|
@target(name="profile-s0", kind=TargetKind.DXF)
|
|
def profile_s0(self) -> Cq.Sketch:
|
|
tip_x = self.shoulder_tip_x
|
|
tip_y = self.shoulder_tip_y
|
|
mid_x = self.shoulder_mid_x
|
|
mid_y = self.shoulder_mid_y
|
|
sw = self.shoulder_width
|
|
sketch = (
|
|
self.outer_profile_s0()
|
|
.segment((-self.base_width, 0), (0, 0))
|
|
.segment(
|
|
(tip_x, tip_y),
|
|
(tip_x, tip_y - sw),
|
|
)
|
|
.segment(
|
|
(tip_x, tip_y - sw),
|
|
(mid_x, mid_y),
|
|
)
|
|
.segment(
|
|
(mid_x, mid_y),
|
|
(-self.base_width, 0),
|
|
)
|
|
.assemble()
|
|
)
|
|
return sketch
|
|
|
|
def outer_shell_s0(self) -> Cq.Workplane:
|
|
t = self.panel_thickness
|
|
profile = Cq.Wire.assembleEdges(self.outer_profile_s0().edges().vals())
|
|
result = (
|
|
Cq.Workplane('XZ')
|
|
.rect(t, self.root_height + t*2, centered=(False, False))
|
|
.sweep(profile)
|
|
)
|
|
plane = result.copyWorkplane(Cq.Workplane('XZ'))
|
|
plane.moveTo(0, 0).tagPlane("bot")
|
|
plane.moveTo(0, self.root_height + t*2).tagPlane("top")
|
|
return result
|
|
|
|
@submodel(name="spacer-s0-shoulder")
|
|
def spacer_s0_shoulder(self) -> MountingBox:
|
|
"""
|
|
Should be cut
|
|
"""
|
|
holes = [
|
|
hole
|
|
for i, (x, y) in enumerate(self.shoulder_joint.parent_conn_hole_pos)
|
|
for hole in [
|
|
Hole(x=x, y=y, tag=f"conn_top{i}"),
|
|
Hole(x=-x, y=y, tag=f"conn_bot{i}"),
|
|
]
|
|
]
|
|
return MountingBox(
|
|
length=self.shoulder_joint.height,
|
|
width=self.shoulder_joint.parent_lip_width,
|
|
thickness=self.spacer_thickness,
|
|
holes=holes,
|
|
hole_diam=self.shoulder_joint.parent_conn_hole_diam,
|
|
centred=(True, True),
|
|
flip_y=self.flip,
|
|
)
|
|
@submodel(name="spacer-s0-shoulder")
|
|
def spacer_s0_base(self) -> MountingBox:
|
|
"""
|
|
Should be cut
|
|
"""
|
|
assert self.base_plate_width < self.base_width
|
|
assert self.hs_joint_corner_dx * 2 < self.base_width
|
|
assert self.hs_joint_corner_dz * 2 < self.root_height
|
|
dy = self.hs_joint_corner_dx
|
|
dx = self.hs_joint_corner_dz
|
|
holes = [
|
|
Hole(x=-dx, y=-dy),
|
|
Hole(x=dx, y=-dy),
|
|
Hole(x=dx, y=dy),
|
|
Hole(x=-dx, y=dy),
|
|
]
|
|
return MountingBox(
|
|
length=self.root_height,
|
|
width=self.base_plate_width,
|
|
thickness=self.spacer_thickness,
|
|
holes=holes,
|
|
hole_diam=self.hs_joint_corner_hole_diam,
|
|
centred=(True, True),
|
|
flip_y=self.flip,
|
|
)
|
|
|
|
def surface_s0(self, top: bool = False) -> Cq.Workplane:
|
|
base_dx = -(self.base_width - self.base_plate_width) / 2
|
|
base_dy = self.base_joint.joint_height
|
|
sw = self.shoulder_width
|
|
|
|
axle_dist = self.shoulder_joint.parent_lip_ext
|
|
theta = math.radians(self.shoulder_joint.angle_neutral)
|
|
c, s = math.cos(-theta), math.sin(-theta)
|
|
tags = [
|
|
# transforms [axle_dist, -sw/2] about the centre (tip_x, tip_y - sw/2)
|
|
("shoulder", (
|
|
self.shoulder_tip_x + axle_dist * c + (-sw/2) * s,
|
|
self.shoulder_tip_y - sw / 2 - axle_dist * s + (-sw/2) * c),
|
|
self.shoulder_joint.angle_neutral),
|
|
("base", (base_dx, base_dy), 90),
|
|
]
|
|
result = nhf.utils.extrude_with_markers(
|
|
self.profile_s0(),
|
|
self.panel_thickness,
|
|
tags,
|
|
reverse=not top,
|
|
)
|
|
h = self.panel_thickness if top else 0
|
|
result.copyWorkplane(Cq.Workplane('XZ')).moveTo(0, h).tagPlane("corner")
|
|
return result
|
|
|
|
@assembly()
|
|
def assembly_s0(self) -> Cq.Assembly:
|
|
result = (
|
|
Cq.Assembly()
|
|
.addS(self.surface_s0(top=True), name="bot",
|
|
material=self.mat_panel, role=self.role_panel)
|
|
.addS(self.surface_s0(top=False), name="top",
|
|
material=self.mat_panel, role=self.role_panel,
|
|
loc=Cq.Location((0, 0, self.root_height + self.panel_thickness)))
|
|
.constrain("bot", "Fixed")
|
|
.constrain("top", "Fixed")
|
|
#.constrain("bot@faces@>Z", "top@faces@<Z", "Point",
|
|
# param=self.shoulder_joint.height)
|
|
.addS(self.outer_shell_s0(), name="outer_shell",
|
|
material=self.mat_panel, role=self.role_panel)
|
|
.constrain("bot?corner", "outer_shell?bot", "Plane", param=0)
|
|
.constrain("top?corner", "outer_shell?top", "Plane", param=0)
|
|
)
|
|
for o, tag in [
|
|
(self.spacer_s0_shoulder().generate(), "shoulder"),
|
|
(self.spacer_s0_base().generate(), "base")
|
|
]:
|
|
top_tag, bot_tag = "top", "bot"
|
|
if self.flip:
|
|
top_tag, bot_tag = bot_tag, top_tag
|
|
(
|
|
result
|
|
.addS(o, name=tag,
|
|
role=Role.STRUCTURE | Role.CONNECTION,
|
|
material=self.mat_bracket)
|
|
.constrain(f"{tag}?{bot_tag}", f"bot?{tag}", "Plane")
|
|
.constrain(f"{tag}?{top_tag}", f"top?{tag}", "Plane")
|
|
.constrain(f"{tag}?dir", f"top?{tag}_dir", "Axis")
|
|
)
|
|
hs_joint = self.base_hs_joint()
|
|
(
|
|
result
|
|
.addS(hs_joint, name="hs", role=Role.CHILD, material=self.mat_hs_joint)
|
|
.constrain("hs?conn0", "base?conn0", "Plane", param=0)
|
|
.constrain("hs?conn1", "base?conn1", "Plane", param=0)
|
|
.constrain("hs?conn2", "base?conn2", "Plane", param=0)
|
|
)
|
|
return result.solve()
|
|
|
|
|
|
### s1, s2, s3 ###
|
|
def profile(self) -> Cq.Sketch:
|
|
"""
|
|
Generates profile from shoulder and above
|
|
"""
|
|
|
|
def _assembly_insert_spacer(
|
|
self,
|
|
a: Cq.Assembly,
|
|
spacer: Cq.Workplane,
|
|
point_tag: str,
|
|
front_tag: str = "front",
|
|
back_tag: str = "back",
|
|
flipped: bool = False,
|
|
rotate: bool = False,
|
|
):
|
|
"""
|
|
For a child joint facing up, front panel should be on the right, back
|
|
panel on the left
|
|
"""
|
|
site_front, site_back = "right", "left"
|
|
if flipped:
|
|
site_front, site_back = site_back, site_front
|
|
angle = 180 if rotate else 0
|
|
(
|
|
a
|
|
.addS(
|
|
spacer,
|
|
name=point_tag,
|
|
material=self.mat_bracket,
|
|
role=self.role_panel)
|
|
.constrain(f"{front_tag}?{point_tag}",
|
|
f"{point_tag}?{site_front}", "Plane")
|
|
.constrain(f"{back_tag}?{point_tag}",
|
|
f"{point_tag}?{site_back}", "Plane")
|
|
.constrain(f"{point_tag}?dir", f"{front_tag}?{point_tag}_dir",
|
|
"Axis", param=angle)
|
|
)
|
|
|
|
def elbow_to_abs(self, x: float, y: float) -> Tuple[float, float]:
|
|
elbow_x = self.elbow_x + x * self.elbow_c - y * self.elbow_s
|
|
elbow_y = self.elbow_y + x * self.elbow_s + y * self.elbow_c
|
|
return elbow_x, elbow_y
|
|
def wrist_to_abs(self, x: float, y: float) -> Tuple[float, float]:
|
|
wrist_x = self.wrist_x + x * self.wrist_c - y * self.wrist_s
|
|
wrist_y = self.wrist_y + x * self.wrist_s + y * self.wrist_c
|
|
return wrist_x, wrist_y
|
|
|
|
|
|
def _mask_elbow(self) -> list[Tuple[float, float]]:
|
|
"""
|
|
Polygon shape to mask out parts above the elbow
|
|
"""
|
|
def _mask_wrist(self) -> list[Tuple[float, float]]:
|
|
"""
|
|
Polygon shape to mask wrist
|
|
"""
|
|
|
|
def spacer_of_joint(
|
|
self,
|
|
joint: ElbowJoint,
|
|
segment_thickness: float,
|
|
dx: float,
|
|
bot=False) -> MountingBox:
|
|
length = joint.lip_length / 2 - dx
|
|
holes = [
|
|
Hole(x - dx)
|
|
for x in joint.hole_pos
|
|
]
|
|
mbox = MountingBox(
|
|
length=length,
|
|
width=segment_thickness,
|
|
thickness=self.spacer_thickness,
|
|
holes=holes,
|
|
hole_diam=joint.hole_diam,
|
|
centred=(False, True),
|
|
)
|
|
return mbox
|
|
|
|
|
|
@target(name="profile-s1", kind=TargetKind.DXF)
|
|
def profile_s1(self) -> Cq.Sketch:
|
|
profile = (
|
|
self.profile()
|
|
.reset()
|
|
.polygon(self._mask_elbow(), mode='i')
|
|
)
|
|
return profile
|
|
def surface_s1(self,
|
|
shoulder_mount_inset: float = 0,
|
|
elbow_mount_inset: float = 0,
|
|
front: bool = True) -> Cq.Workplane:
|
|
shoulder_h = self.shoulder_joint.child_height
|
|
h = (self.shoulder_joint.height - shoulder_h) / 2
|
|
tags_shoulder = [
|
|
("shoulder_bot", (shoulder_mount_inset, h), 90),
|
|
("shoulder_top", (shoulder_mount_inset, h + shoulder_h), 270),
|
|
]
|
|
h = self.elbow_height / 2
|
|
tags_elbow = [
|
|
("elbow_bot",
|
|
self.elbow_to_abs(-elbow_mount_inset, h - self.elbow_h2),
|
|
self.elbow_angle + 0),
|
|
("elbow_top",
|
|
self.elbow_to_abs(-elbow_mount_inset, h + self.elbow_h2),
|
|
self.elbow_angle + 0),
|
|
]
|
|
profile = self.profile_s1()
|
|
tags = tags_shoulder + tags_elbow
|
|
return nhf.utils.extrude_with_markers(
|
|
profile, self.panel_thickness, tags, reverse=front)
|
|
@submodel(name="spacer-s1-shoulder")
|
|
def spacer_s1_shoulder(self) -> MountingBox:
|
|
holes = [
|
|
Hole(x)
|
|
for x in self.shoulder_joint.child_conn_hole_pos
|
|
]
|
|
return MountingBox(
|
|
length=50.0, # FIXME: magic
|
|
width=self.s1_thickness,
|
|
thickness=self.spacer_thickness,
|
|
holes=holes,
|
|
hole_diam=self.shoulder_joint.child_conn_hole_diam,
|
|
)
|
|
@submodel(name="spacer-s1-elbow")
|
|
def spacer_s1_elbow(self) -> MountingBox:
|
|
return self.spacer_of_joint(
|
|
joint=self.elbow_joint,
|
|
segment_thickness=self.s1_thickness,
|
|
dx=self.elbow_h2,
|
|
)
|
|
@assembly()
|
|
def assembly_s1(self) -> Cq.Assembly:
|
|
result = (
|
|
Cq.Assembly()
|
|
.addS(self.surface_s1(front=True), name="front",
|
|
material=self.mat_panel, role=self.role_panel)
|
|
.constrain("front", "Fixed")
|
|
.addS(self.surface_s1(front=False), name="back",
|
|
material=self.mat_panel, role=self.role_panel)
|
|
.constrain("front@faces@>Z", "back@faces@<Z", "Point",
|
|
param=self.s1_thickness)
|
|
)
|
|
for t in ["shoulder_bot", "shoulder_top", "elbow_bot", "elbow_top"]:
|
|
is_top = t.endswith("_top")
|
|
is_parent = t.startswith("shoulder")
|
|
o = self.spacer_s1_shoulder().generate() if is_parent else self.spacer_s1_elbow().generate()
|
|
self._assembly_insert_spacer(
|
|
result,
|
|
o,
|
|
point_tag=t,
|
|
flipped=not is_top,
|
|
)
|
|
return result.solve()
|
|
|
|
@target(name="profile-s2", kind=TargetKind.DXF)
|
|
def profile_s2(self) -> Cq.Sketch:
|
|
profile = (
|
|
self.profile()
|
|
.reset()
|
|
.polygon(self._mask_elbow(), mode='s')
|
|
.reset()
|
|
.polygon(self._mask_wrist(), mode='i')
|
|
)
|
|
return profile
|
|
def surface_s2(self,
|
|
elbow_mount_inset: float = 0,
|
|
wrist_mount_inset: float = 0,
|
|
front: bool = True) -> Cq.Workplane:
|
|
h = self.elbow_height / 2
|
|
tags_elbow = [
|
|
("elbow_bot",
|
|
self.elbow_to_abs(elbow_mount_inset, h - self.elbow_h2),
|
|
self.elbow_angle + 180),
|
|
("elbow_top",
|
|
self.elbow_to_abs(elbow_mount_inset, h + self.elbow_h2),
|
|
self.elbow_angle + 180),
|
|
]
|
|
h = self.wrist_height / 2
|
|
tags_wrist = [
|
|
("wrist_bot",
|
|
self.wrist_to_abs(-wrist_mount_inset, h - self.wrist_h2),
|
|
self.wrist_angle),
|
|
("wrist_top",
|
|
self.wrist_to_abs(-wrist_mount_inset, h + self.wrist_h2),
|
|
self.wrist_angle),
|
|
]
|
|
profile = self.profile_s2()
|
|
tags = tags_elbow + tags_wrist
|
|
return nhf.utils.extrude_with_markers(profile, self.panel_thickness, tags, reverse=front)
|
|
@submodel(name="spacer-s2-elbow")
|
|
def spacer_s2_elbow(self) -> MountingBox:
|
|
return self.spacer_of_joint(
|
|
joint=self.elbow_joint,
|
|
segment_thickness=self.s2_thickness,
|
|
dx=self.elbow_h2,
|
|
)
|
|
@submodel(name="spacer-s2-wrist")
|
|
def spacer_s2_wrist(self) -> MountingBox:
|
|
return self.spacer_of_joint(
|
|
joint=self.wrist_joint,
|
|
segment_thickness=self.s2_thickness,
|
|
dx=self.wrist_h2,
|
|
)
|
|
@assembly()
|
|
def assembly_s2(self) -> Cq.Assembly:
|
|
result = (
|
|
Cq.Assembly()
|
|
.addS(self.surface_s2(front=True), name="front",
|
|
material=self.mat_panel, role=self.role_panel)
|
|
.constrain("front", "Fixed")
|
|
.addS(self.surface_s2(front=False), name="back",
|
|
material=self.mat_panel, role=self.role_panel)
|
|
.constrain("front@faces@>Z", "back@faces@<Z", "Point",
|
|
param=self.s1_thickness)
|
|
)
|
|
for t in ["elbow_bot", "elbow_top", "wrist_bot", "wrist_top"]:
|
|
is_top = t.endswith("_top")
|
|
is_parent = t.startswith("elbow")
|
|
o = self.spacer_s2_elbow() if is_parent else self.spacer_s2_wrist()
|
|
self._assembly_insert_spacer(
|
|
result,
|
|
o.generate(),
|
|
point_tag=t,
|
|
flipped=is_top == is_parent,
|
|
#rotate=True,
|
|
)
|
|
return result.solve()
|
|
|
|
@target(name="profile-s3", kind=TargetKind.DXF)
|
|
def profile_s3(self) -> Cq.Sketch:
|
|
profile = (
|
|
self.profile()
|
|
.reset()
|
|
.polygon(self._mask_wrist(), mode='s')
|
|
)
|
|
return profile
|
|
def surface_s3(self,
|
|
front: bool = True) -> Cq.Workplane:
|
|
wrist_mount_inset = 0
|
|
h = self.wrist_height / 2
|
|
tags = [
|
|
("wrist_bot",
|
|
self.wrist_to_abs(wrist_mount_inset, h - self.wrist_h2),
|
|
self.wrist_angle + 180),
|
|
("wrist_top",
|
|
self.wrist_to_abs(wrist_mount_inset, h + self.wrist_h2),
|
|
self.wrist_angle + 180),
|
|
]
|
|
profile = self.profile_s3()
|
|
return nhf.utils.extrude_with_markers(profile, self.panel_thickness, tags, reverse=front)
|
|
@submodel(name="spacer-s3-wrist")
|
|
def spacer_s3_wrist(self) -> MountingBox:
|
|
return self.spacer_of_joint(
|
|
joint=self.wrist_joint,
|
|
segment_thickness=self.s3_thickness,
|
|
dx=self.wrist_h2,
|
|
)
|
|
@assembly()
|
|
def assembly_s3(self) -> Cq.Assembly:
|
|
result = (
|
|
Cq.Assembly()
|
|
.addS(self.surface_s3(front=True), name="front",
|
|
material=self.mat_panel, role=self.role_panel)
|
|
.constrain("front", "Fixed")
|
|
.addS(self.surface_s3(front=False), name="back",
|
|
material=self.mat_panel, role=self.role_panel)
|
|
.constrain("front@faces@>Z", "back@faces@<Z", "Point",
|
|
param=self.s1_thickness)
|
|
)
|
|
for t in ["wrist_bot", "wrist_top"]:
|
|
is_top = t.endswith("_top")
|
|
is_parent = True
|
|
o = self.spacer_s3_wrist()
|
|
self._assembly_insert_spacer(
|
|
result,
|
|
o.generate(),
|
|
point_tag=t,
|
|
flipped=is_top,# != is_parent,
|
|
#rotate=True,
|
|
)
|
|
return result.solve()
|
|
|
|
@assembly()
|
|
def assembly(self,
|
|
parts: Optional[list[str]] = None,
|
|
angle_elbow_wrist: float = 0.0,
|
|
) -> Cq.Assembly():
|
|
if parts is None:
|
|
parts = ["s0", "shoulder", "s1", "elbow", "s2", "wrist", "s3"]
|
|
result = (
|
|
Cq.Assembly()
|
|
)
|
|
tag_top, tag_bot = "top", "bot"
|
|
if self.flip:
|
|
tag_top, tag_bot = tag_bot, tag_top
|
|
|
|
if "s0" in parts:
|
|
result.add(self.assembly_s0(), name="s0")
|
|
if "shoulder" in parts:
|
|
result.add(self.shoulder_joint.assembly(), name="shoulder")
|
|
if "s0" in parts and "shoulder" in parts:
|
|
(
|
|
result
|
|
.constrain(f"s0/shoulder?conn_top0", f"shoulder/parent_{tag_top}/lip?conn0", "Plane")
|
|
.constrain(f"s0/shoulder?conn_top1", f"shoulder/parent_{tag_top}/lip?conn1", "Plane")
|
|
.constrain(f"s0/shoulder?conn_bot0", f"shoulder/parent_{tag_bot}/lip?conn0", "Plane")
|
|
.constrain(f"s0/shoulder?conn_bot1", f"shoulder/parent_{tag_bot}/lip?conn1", "Plane")
|
|
)
|
|
if "s1" in parts:
|
|
result.add(self.assembly_s1(), name="s1")
|
|
if "s1" in parts and "shoulder" in parts:
|
|
(
|
|
result
|
|
.constrain("s1/shoulder_top?conn0", f"shoulder/child/lip_{tag_top}?conn0", "Plane")
|
|
.constrain("s1/shoulder_top?conn1", f"shoulder/child/lip_{tag_top}?conn1", "Plane")
|
|
.constrain("s1/shoulder_bot?conn0", f"shoulder/child/lip_{tag_bot}?conn0", "Plane")
|
|
.constrain("s1/shoulder_bot?conn1", f"shoulder/child/lip_{tag_bot}?conn1", "Plane")
|
|
)
|
|
if "elbow" in parts:
|
|
result.add(self.elbow_joint.assembly(angle=angle_elbow_wrist), name="elbow")
|
|
if "s1" in parts and "elbow" in parts:
|
|
(
|
|
result
|
|
.constrain("s1/elbow_top?conn0", "elbow/parent_upper/lip?conn_top0", "Plane")
|
|
.constrain("s1/elbow_top?conn1", "elbow/parent_upper/lip?conn_top1", "Plane")
|
|
.constrain("s1/elbow_bot?conn0", "elbow/parent_upper/lip?conn_bot0", "Plane")
|
|
.constrain("s1/elbow_bot?conn1", "elbow/parent_upper/lip?conn_bot1", "Plane")
|
|
)
|
|
if "s2" in parts:
|
|
result.add(self.assembly_s2(), name="s2")
|
|
if "s2" in parts and "elbow" in parts:
|
|
(
|
|
result
|
|
.constrain("s2/elbow_top?conn0", "elbow/child/lip?conn_top0", "Plane")
|
|
.constrain("s2/elbow_top?conn1", "elbow/child/lip?conn_top1", "Plane")
|
|
.constrain("s2/elbow_bot?conn0", "elbow/child/lip?conn_bot0", "Plane")
|
|
.constrain("s2/elbow_bot?conn1", "elbow/child/lip?conn_bot1", "Plane")
|
|
)
|
|
if "wrist" in parts:
|
|
result.add(self.wrist_joint.assembly(angle=angle_elbow_wrist), name="wrist")
|
|
if "s2" in parts and "wrist" in parts:
|
|
# Mounted backwards to bend in other direction
|
|
(
|
|
result
|
|
.constrain("s2/wrist_top?conn0", "wrist/parent_upper/lip?conn_bot0", "Plane")
|
|
.constrain("s2/wrist_top?conn1", "wrist/parent_upper/lip?conn_bot1", "Plane")
|
|
.constrain("s2/wrist_bot?conn0", "wrist/parent_upper/lip?conn_top0", "Plane")
|
|
.constrain("s2/wrist_bot?conn1", "wrist/parent_upper/lip?conn_top1", "Plane")
|
|
)
|
|
if "s3" in parts:
|
|
result.add(self.assembly_s3(), name="s3")
|
|
if "s3" in parts and "wrist" in parts:
|
|
(
|
|
result
|
|
.constrain("s3/wrist_top?conn0", "wrist/child/lip?conn_bot0", "Plane")
|
|
.constrain("s3/wrist_top?conn1", "wrist/child/lip?conn_bot1", "Plane")
|
|
.constrain("s3/wrist_bot?conn0", "wrist/child/lip?conn_top0", "Plane")
|
|
.constrain("s3/wrist_bot?conn1", "wrist/child/lip?conn_top1", "Plane")
|
|
)
|
|
if len(parts) > 1:
|
|
result.solve()
|
|
|
|
return result
|
|
|
|
|
|
|
|
@dataclass(kw_only=True)
|
|
class WingR(WingProfile):
|
|
"""
|
|
Right side wings
|
|
"""
|
|
|
|
elbow_height: float = 111.0
|
|
elbow_x: float = 285.0
|
|
elbow_y: float = 5.0
|
|
# Tilt of elbow w.r.t. shoulder
|
|
elbow_angle: float = 25.0
|
|
|
|
wrist_height: float = 60.0
|
|
# Bottom point of the wrist
|
|
wrist_x: float = 403.0
|
|
wrist_y: float = 253.0
|
|
|
|
# Tile of wrist w.r.t. shoulder
|
|
wrist_angle: float = 40
|
|
# Extends from the wrist to the tip of the arrow
|
|
arrow_height: float = 300
|
|
arrow_angle: float = 8
|
|
|
|
# Relative (in wrist coordinate) centre of the ring
|
|
ring_x: float = 45
|
|
ring_y: float = 25
|
|
ring_radius_inner: float = 22
|
|
|
|
def __post_init__(self):
|
|
super().__post_init__()
|
|
self.arrow_theta = math.radians(self.arrow_angle)
|
|
self.arrow_x, self.arrow_y = self.wrist_to_abs(0, -self.arrow_height)
|
|
self.arrow_tip_x = self.arrow_x + (self.arrow_height + self.wrist_height) \
|
|
* math.sin(self.arrow_theta - self.wrist_theta)
|
|
self.arrow_tip_y = self.arrow_y + (self.arrow_height + self.wrist_height) \
|
|
* math.cos(self.arrow_theta - self.wrist_theta)
|
|
# [[c, s], [-s, c]] * [ring_x, ring_y]
|
|
self.ring_abs_x = self.wrist_top_x + self.wrist_c * self.ring_x - self.wrist_s * self.ring_y
|
|
self.ring_abs_y = self.wrist_top_y + self.wrist_s * self.ring_x + self.wrist_c * self.ring_y
|
|
assert self.ring_radius > self.ring_radius_inner
|
|
|
|
@property
|
|
def ring_radius(self) -> float:
|
|
dx = self.ring_x
|
|
dy = self.ring_y
|
|
return (dx * dx + dy * dy) ** 0.5
|
|
|
|
def profile(self) -> Cq.Sketch:
|
|
"""
|
|
Net profile of the wing starting from the wing root with no divisions
|
|
"""
|
|
result = (
|
|
Cq.Sketch()
|
|
.segment(
|
|
(0, 0),
|
|
(0, self.shoulder_joint.height),
|
|
tag="shoulder")
|
|
.spline([
|
|
(0, self.shoulder_joint.height),
|
|
(self.elbow_top_x, self.elbow_top_y),
|
|
(self.wrist_top_x, self.wrist_top_y),
|
|
],
|
|
tag="s1_top")
|
|
#.segment(
|
|
# (self.wrist_x, self.wrist_y),
|
|
# (wrist_top_x, wrist_top_y),
|
|
# tag="wrist")
|
|
.spline([
|
|
(0, 0),
|
|
(self.elbow_x, self.elbow_y),
|
|
(self.wrist_x, self.wrist_y),
|
|
],
|
|
tag="s1_bot")
|
|
)
|
|
result = (
|
|
result
|
|
.segment(
|
|
(self.wrist_x, self.wrist_y),
|
|
(self.arrow_x, self.arrow_y)
|
|
)
|
|
.segment(
|
|
(self.arrow_x, self.arrow_y),
|
|
(self.arrow_tip_x, self.arrow_tip_y)
|
|
)
|
|
.segment(
|
|
(self.arrow_tip_x, self.arrow_tip_y),
|
|
(self.wrist_top_x, self.wrist_top_y)
|
|
)
|
|
)
|
|
# Carve out the ring
|
|
result = result.assemble()
|
|
result = (
|
|
result
|
|
.push([(self.ring_abs_x, self.ring_abs_y)])
|
|
.circle(self.ring_radius, mode='a')
|
|
.circle(self.ring_radius_inner, mode='s')
|
|
.clean()
|
|
)
|
|
return result
|
|
|
|
def _mask_elbow(self) -> list[Tuple[float, float]]:
|
|
l = 200
|
|
return [
|
|
(0, -l),
|
|
(self.elbow_x, -l),
|
|
(self.elbow_x, self.elbow_y),
|
|
(self.elbow_top_x, self.elbow_top_y),
|
|
(self.elbow_top_x, l),
|
|
(0, l)
|
|
]
|
|
|
|
def _mask_wrist(self) -> list[Tuple[float, float]]:
|
|
l = 200
|
|
return [
|
|
(0, -l),
|
|
(self.wrist_x, -l),
|
|
(self.wrist_x, self.wrist_y),
|
|
(self.wrist_top_x, self.wrist_top_y),
|
|
#(self.wrist_top_x, self.wrist_top_y),
|
|
(0, self.wrist_top_y),
|
|
]
|
|
|
|
|
|
@dataclass(kw_only=True)
|
|
class WingL(WingProfile):
|
|
|
|
elbow_x: float = 230.0
|
|
elbow_y: float = 110.0
|
|
elbow_angle: float = -10.0
|
|
elbow_height: float = 80.0
|
|
|
|
wrist_x: float = 480.0
|
|
wrist_y: float = 0.0
|
|
wrist_angle: float = -45
|
|
wrist_height: float = 43.0
|
|
|
|
shoulder_bezier_ext: float = 80.0
|
|
elbow_bezier_ext: float = 100.0
|
|
wrist_bezier_ext: float = 30.0
|
|
|
|
arrow_length: float = 135.0
|
|
arrow_height: float = 120.0
|
|
|
|
flip: bool = True
|
|
|
|
def __post_init__(self):
|
|
super().__post_init__()
|
|
assert self.wrist_height <= self.shoulder_joint.height
|
|
|
|
def arrow_to_abs(self, x, y) -> Tuple[float, float]:
|
|
return self.wrist_to_abs(x * self.arrow_length, y * self.arrow_height / 2 + self.wrist_height / 2)
|
|
|
|
def profile(self) -> Cq.Sketch:
|
|
result = (
|
|
Cq.Sketch()
|
|
.segment(
|
|
(0,0),
|
|
(0, self.shoulder_height)
|
|
)
|
|
#.spline([
|
|
# (0, 0),
|
|
# self.elbow_to_abs(0, 0),
|
|
# self.wrist_to_abs(0, 0),
|
|
#])
|
|
#.spline([
|
|
# (0, self.shoulder_height),
|
|
# self.elbow_to_abs(0, self.elbow_height),
|
|
# self.wrist_to_abs(0, self.wrist_height),
|
|
#])
|
|
.bezier([
|
|
(0, 0),
|
|
(self.shoulder_bezier_ext, 0),
|
|
self.elbow_to_abs(-self.elbow_bezier_ext, 0),
|
|
self.elbow_to_abs(0, 0),
|
|
])
|
|
.bezier([
|
|
(0, self.shoulder_joint.height),
|
|
(self.shoulder_bezier_ext, self.shoulder_joint.height),
|
|
self.elbow_to_abs(-self.elbow_bezier_ext, self.elbow_height),
|
|
self.elbow_to_abs(0, self.elbow_height),
|
|
])
|
|
.bezier([
|
|
self.elbow_to_abs(0, 0),
|
|
self.elbow_to_abs(self.elbow_bezier_ext, 0),
|
|
self.wrist_to_abs(-self.wrist_bezier_ext, 0),
|
|
self.wrist_to_abs(0, 0),
|
|
])
|
|
.bezier([
|
|
self.elbow_to_abs(0, self.elbow_height),
|
|
self.elbow_to_abs(self.elbow_bezier_ext, self.elbow_height),
|
|
self.wrist_to_abs(-self.wrist_bezier_ext, self.wrist_height),
|
|
self.wrist_to_abs(0, self.wrist_height),
|
|
])
|
|
)
|
|
# arrow base positions
|
|
base_u, base_v = 0.3, 0.3
|
|
result = (
|
|
result
|
|
.bezier([
|
|
self.wrist_to_abs(0, self.wrist_height),
|
|
self.wrist_to_abs(self.wrist_bezier_ext, self.wrist_height),
|
|
self.arrow_to_abs(base_u, base_v),
|
|
])
|
|
.bezier([
|
|
self.wrist_to_abs(0, 0),
|
|
self.wrist_to_abs(self.wrist_bezier_ext, 0),
|
|
self.arrow_to_abs(base_u, -base_v),
|
|
])
|
|
)
|
|
# Create the arrow
|
|
arrow_beziers = [
|
|
[
|
|
(0, 1),
|
|
(0.3, 1),
|
|
(0.8, .2),
|
|
(1, 0),
|
|
],
|
|
[
|
|
(0, 1),
|
|
(0.1, 0.8),
|
|
(base_u, base_v),
|
|
]
|
|
]
|
|
arrow_beziers = [
|
|
l2
|
|
for l in arrow_beziers
|
|
for l2 in [l, [(x, -y) for x,y in l]]
|
|
]
|
|
for line in arrow_beziers:
|
|
result = result.bezier([self.arrow_to_abs(x, y) for x,y in line])
|
|
return result.assemble()
|
|
|
|
def _mask_elbow(self) -> list[Tuple[float, float]]:
|
|
l = 200
|
|
return [
|
|
(0, -l),
|
|
(self.elbow_x, -l),
|
|
(self.elbow_x, self.elbow_y),
|
|
(self.elbow_top_x, self.elbow_top_y),
|
|
(self.elbow_top_x, l),
|
|
(0, l)
|
|
]
|
|
|
|
def _mask_wrist(self) -> list[Tuple[float, float]]:
|
|
l = 200
|
|
return [
|
|
(0, -l),
|
|
(self.elbow_x, self.wrist_y),
|
|
(self.wrist_x, self.wrist_y),
|
|
(self.wrist_top_x, self.wrist_top_y),
|
|
(self.elbow_x, self.elbow_top_y + l),
|
|
(0, l),
|
|
]
|