cadquery_files/segment_gehauese/zellhalter_v3_injection.py

import cadquery as cq
from cadquery.occ_impl.exporters import ExportTypes

from ocp_vscode import show, show_object


# Zellhalter für Injection Moulding

###### Parameter #####
cells_per_row = 8
rows = 2

cell_diam = 18.44
cell_length = 65
dist_to_ground = 66.9
space_all = 140
space_single = space_all / (cells_per_row - 1)
space_rows = 33.7

dist_segments = 57.5

strip_width = 10.4

print_height = 15
wall_thick = 1.7
eps = 0.15

hole_diam = 2.4
hole_depth = 10
board_connector_length = dist_to_ground + wall_thick
lip_width = 1.5
lip_thick = 1.5

############

cell_locs = [(x * space_single, y * space_rows) for x in range(0, cells_per_row) for y in range(0, rows)]
strip_locs = [(-cell_diam/4, y * space_rows) for y in range(0, rows)]
row_connector_locs = [(x * space_single * 2, (y + 0.5) * space_rows) for x in range(0, int(cells_per_row/2)) for y in range(0, rows-1)]

cell_edge = cell_diam/2 - 1.5

board_con_locs_with_rot = [
   ((-.5 * space_single, -cell_edge), 0),
   ((-.5 * space_single, space_rows + cell_edge), 180),
   ((5.5 * space_single, cell_edge), 180),
   ((5.5 * space_single, space_rows - cell_edge), 0),
]

# Zellkreise
cell_base = (
   cq.Workplane()
   .pushPoints(cell_locs)
   .eachpoint(
      lambda loc: (
         cq.Workplane()
         .circle(cell_diam/2 + eps + wall_thick)
         .extrude(print_height)
         .val()
         .located(loc)
      )
   )
)
# Ausschnitt für die Zellen
cell_cutout = (
   cq.Workplane()
   .pushPoints(cell_locs)
   .eachpoint(
      lambda loc: (
         cq.Workplane()
         .circle(cell_diam/2 + eps)
         .extrude(print_height-wall_thick)
         .val()
         .located(loc)
      )
   )
)

# Ausschnitt für die Lötfahne
strips_cut = (
   cq.Workplane()
   .pushPoints(strip_locs)
   .eachpoint(
      lambda loc: (
         cq.Workplane().workplane(offset=print_height-2*wall_thick)
         .rect(space_all + cell_diam/2+wall_thick, strip_width, centered=(False, True))
         .extrude(wall_thick*2)
         .val()
         .located(loc)
      )
   )
)
strips_wall = (
   cq.Workplane()
   .pushPoints(strip_locs)
   .eachpoint(
      lambda loc: (
         cq.Workplane()
         .rect(space_all+ 2*wall_thick, strip_width + 2*wall_thick, centered=(False, True))
         .extrude(print_height)
         .val()
         .located(loc)
      )
   )
)
base_cutout = cell_base.union(strips_wall).cut(cell_cutout)

row_connectors = (
   cq.Workplane()
   .pushPoints(row_connector_locs)
   .eachpoint(
      lambda loc: (
         cq.Workplane().workplane(offset=wall_thick)
         .rect(wall_thick, space_rows - cell_diam - wall_thick, centered=(False, True))
         .extrude(print_height-wall_thick)
         .val()
         .located(loc)
      )
   )
)
base_connected = base_cutout.union(row_connectors)

connector_width = hole_diam + wall_thick*2
connector_print_height = print_height+wall_thick/2
board_con = (
   cq.Workplane(origin=(0,0,print_height))
   .circle(connector_width/2)
   .extrude(-connector_print_height)
   .faces("<Z")
   .chamfer(wall_thick/2)
   .faces("<Z")
   .workplane()
   .circle(connector_width/2-wall_thick/2)
   .extrude(board_connector_length-connector_print_height)
   .faces("<Z")
   .workplane()
   .circle(hole_diam/2)
   .cutBlind(-hole_depth)
)

# Runde bordconnector mit Loch am Ende
for location, angle in board_con_locs_with_rot:
   con = board_con.translate(location)
   con = con.rotateAboutCenter((0,0,1), angle)
   base_connected = base_connected.union(con)

# Schneide die Lötstreifen aus
base_connected = base_connected.cut(strips_cut)

# Fase and Connectors
test = base_connected.edges("|Z")

# Begrenzungsbox für den gesamten Zellhalter (sonst schneidet man den nächsten Halter)
boundary_box = (
   base_connected.workplane(centerOption="CenterOfBoundBox")
   .box(1000, dist_segments, 1000,combine=False)
)
base_connected = base_connected.intersect(boundary_box)

show_object(base_connected)

with open(r"zellhalter_v3.step", "w") as fp:
   cq.exporters.exportShape(base_connected, ExportTypes.STEP, fp)