def oscad_draw_void(self):
trans = self.get_trans_to_solid() + pa.point_t(0, self.inset, 0)
trans_male = trans + pa.point_t((width - inner_width) * 0.5, 0,
(height - inner_height) * 0.5)
# First cut out for the USB jack, then cut the hole for the male part
# access
return ("""
translate([{trans.x},{trans.y},{trans.z}])
cube([{voiddims[0]},{voiddims[1]},{voiddims[2]}]);
translate([{trans_male.x},{trans_male.y},{trans_male.z}])
cube([{malevoiddims[0]},{malevoiddims[1]},{malevoiddims[2]}]);
""".format(trans=trans,
voiddims=[width, length - self.inset, height],
trans_male=trans_male,
malevoiddims=[inner_width, hole_depth, inner_height]))
def oscad_draw_void(self):
trans = self.get_trans_to_solid() + pa.point_t(dims.x * 0.5,
shaft_center_y, 0)
return ("""
translate([{trans.x},{trans.y},{trans.z}])
cylinder(r={shaft_radius},h={height});
""".format(trans=trans,
shaft_radius=shaft_diameter * 0.5 + shaft_gap,
height=height))
def oscad_draw_solid(self):
trans = self.get_trans_to_solid() + pa.point_t(
1., 1., 0) * (wall_thickness + button_gap + key_extra)
dims = pa.point_t(width, length, height)
trans_centre = [dims.x * 0.5, dims.y * 0.5, 0]
top_height = height - bottom_height
# return ""
return ("""
translate([{trans.x},{trans.y},{trans.z}])
cube([{dims.x},{dims.y},{bottom_height}]);
translate([{trans.x},{trans.y},{trans.z}])
translate([{trans_centre[0]},{trans_centre[1]},{trans_centre[2]}])
cylinder(r={button_rad},h={height});
""".format(trans=trans,
dims=dims,
trans_centre=trans_centre,
bottom_height=bottom_height,
button_rad=button_diameter * 0.5,
height=height))
def oscad_draw_void(self):
trans = self.get_trans_to_solid() + pa.point_t(0, self.inset, 0)
return ("""
translate([{trans.x},{trans.y},{trans.z}])
cube([{voiddims[0]},{voiddims[1]},{voiddims[2]}]);
""".format(trans=trans, voiddims=[width, hole_depth, height]))
import dcjack as dj
import domepartconfig as dpc
wallgap=dpc.wall_thickness
midi_jack_out=mj.midi_jack_t(hole_relative_to_bottom=False)
midi_jack_in=mj.midi_jack_t(hole_relative_to_bottom=False)
dc_jack=dj.dc_jack_t(overhang=wallgap+1)
parts=[ midi_jack_out ]
parts=pa.stick_on_part(parts,midi_jack_in,'e',('','+','+'),False)
parts=pa.stick_on_part(parts,dc_jack,'e',('','+','+'),False)
co,di=pa.parts_hull(parts)
back_wall= pa.cube_t(coords=(co-pa.point_t(wallgap,0,wallgap)).as_tuple(),
dims=(di.x+2*wallgap,wallgap,di.z+2*wallgap))
parts=pa.stick_on_part(parts,back_wall,'n',('-','','-'),True)
# The circuit
print('color("MediumSeaGreen") {')
print("difference () {")
print("union () {")
for p in [midi_jack_in,midi_jack_out,dc_jack]:
print(p.oscad_draw_solid())
print("}")
print("union () {")
print("}")
print("}")
print("}")
def oscad_draw_solid(self):
trans = self.get_trans_to_solid()
dims = self.get_dims()
local_trans = dims * 0.5
xspacegap = 2 * wall_thickness
inside_dims = dims - pa.point_t(xspacegap, xspacegap, 0)
shaft_thickness = wall_thickness * 0.5
s = ""
if self.inside:
s_ = ""
# Draw key
s_ += """
translate([{trans.x},{trans.y},{trans.z}])
difference () {{
union () {{
rounded_key(
[{local_trans.x},{local_trans.y},{local_trans.z}],
[{key_dims.x},{key_dims.y},{key_dims.z}],
{corner_radius},
{wall_thickness});
for(trans_=[
[{trans_e.x},{trans_e.y},{trans_e.z}],
[{trans_w.x},{trans_w.y},{trans_w.z}],
[{trans_s.x},{trans_s.y},{trans_s.z}],
[{trans_n.x},{trans_n.y},{trans_n.z}]
]) {{
translate(trans_)
cube([{rail.x},{rail.y},{rail.z}]);
}}
}}
union () {{
"""
if self.keytext:
s_ += """
translate([{key_top_trans.x},{key_top_trans.y},{key_top_trans.z}])
linear_extrude ({keytextthickness}) {{
text("{keytext}",font="{font}",size={fontsize},halign="center",valign="center");
}}
"""
s_ += """
}}
}}
"""
key_gap = wall_thickness + button_gap
key_rail_thickness = shaft_thickness - key_rail_gap
s += s_.format(
trans=trans,
local_trans=pa.point_t(
dims.x * 0.5, dims.y * 0.5,
self.button.get_dims().z + self.keyheight * 0.5),
key_dims=pa.point_t(width + key_extra, length + key_extra,
self.keyheight),
corner_radius=corner_radius,
trans_e=pa.point_t(key_gap - key_rail_thickness,
dims.y * 0.5 - key_rail_thickness * 0.5,
height),
trans_w=pa.point_t(key_gap + width,
dims.y * 0.5 - key_rail_thickness * 0.5,
height),
trans_s=pa.point_t(dims.x * 0.5 - key_rail_thickness * 0.5,
key_gap - key_rail_thickness, height),
trans_n=pa.point_t(dims.x * 0.5 - key_rail_thickness * 0.5,
key_gap + length, height),
rail=pa.point_t(key_rail_thickness, key_rail_thickness,
height),
key_top_trans=pa.point_t(
dims.x * 0.5, dims.y * 0.5,
self.button.get_dims().z + self.keyheight -
keytextthickness),
keytextthickness=keytextthickness,
keytext=self.keytext,
font=self.font,
fontsize=self.fontsize,
wall_thickness=wall_thickness)
# Draw shaft and rails in which key slides
if self.outside:
s_ = """
translate([{trans.x},{trans.y},{trans.z}])
difference () {{
rounded_shaft(
[{local_trans.x},{local_trans.y},{local_trans.z}],
[{inside_dims.x},{inside_dims.y},{inside_dims.z}],
{corner_radius},
{wall_thickness}
);
union () {{
for(trans_=[
[{trans_e.x},{trans_e.y},{trans_e.z}],
[{trans_w.x},{trans_w.y},{trans_w.z}],
[{trans_s.x},{trans_s.y},{trans_s.z}],
[{trans_n.x},{trans_n.y},{trans_n.z}]
]) {{
translate(trans_)
cube([{rail.x},{rail.y},{rail.z}]);
}}
}}
}}
""".format(trans=trans,
local_trans=local_trans,
inside_dims=inside_dims,
corner_radius=corner_radius,
wall_thickness=wall_thickness,
trans_e=pa.point_t(wall_thickness - shaft_thickness,
dims.y * 0.5 - shaft_thickness * 0.5,
0),
trans_w=pa.point_t(wall_thickness + inside_dims.x,
dims.y * 0.5 - shaft_thickness * 0.5,
0),
trans_s=pa.point_t(dims.x * 0.5 - shaft_thickness * 0.5,
wall_thickness - shaft_thickness, 0),
trans_n=pa.point_t(dims.x * 0.5 - shaft_thickness * 0.5,
wall_thickness + inside_dims.y, 0),
rail=pa.point_t(shaft_thickness, shaft_thickness,
inside_dims.z))
s += s_
return s
def get_trans_to_hole_centre(self):
if self.hole_relative_to_bottom:
return pa.point_t(width*0.5,length,hole_centre_height)
else:
return pa.point_t(width*0.5,length,height-hole_centre_height)