Proper fillet

notebook_nueva/audio_plug.py

@@ -1,7 +1,10 @@
 # Hole to expose a USB audio card (YMMV)
 
-# The hole is for a USB-A plug, y is measured in the hub
-# (from the bottom face to middle of the hole)
+import cadquery as cq
+
+from utils import punch_hole
+
+# The hole is for a random USB sound card.
 # Consumers should set proper offsets for the hole
 
 holes = [
@@ -9,8 +12,39 @@ holes = [
     {
         "x": 0,
         "y": 4,
-        "height": 6,
-        "width": 17,
-        "fillet": 2,
+        "shape": cq.Sketch().trapezoid(17, 5, 90, mode="a").vertices().fillet(2),
     },
 ]
+
+
+def add(
+    *,
+    model,
+    width,
+    height,
+    thickness,
+    offset_x,
+    offset_y,
+    bottom_face,
+    back_face,
+    shell_t
+):
+
+    # Holes
+    if back_face:
+        for hole in holes:
+            model = punch_hole(
+                model=model,
+                face=back_face,
+                # FIXME: This is weird because it's the RIGHT side,
+                # So it's height instead of w
+                # need to work on making these coherent
+                w=height,
+                h=thickness,
+                x_offset=offset_x - 17 / 2,
+                y_offset=shell_t,
+                hole=hole,
+                depth=shell_t,
+            )
+
+    return model

notebook_nueva/battery_holder.py

@@ -1,11 +1,14 @@
 import cadquery as cq
 
-stand_positions = [(0, 0), (58, 0), (58, 49), (0, 49)]
+from utils import extrude_shape, punch_hole, hex_vents
+
+stand_positions = [(3.5, 3.5), (61.5, 3.5), (61.5, 52.5), (3.5, 52.5)]
 stands = (
     cq.Sketch().push(stand_positions).circle(3, mode="a").circle(2.65 / 2, mode="s")
 )
 pillar_height = 7
-
+width = 85
+height = 56
 
 # This is a holder for DuPont cables so they connect to this
 # things' pogo pins which are used to power the CPU
@@ -39,16 +42,38 @@ elements = [
         "shape": stands,
         "height": pillar_height,
     },
-    # Pogo pin connector channels
     {
         "x": 0,
-        "y": 40,
+        "y": 0,
+        "shape": cq.Sketch().push(stand_positions).circle(5),
+        "height": 0,
+    },
+    # Pogo pin connector channels
+    {
+        "x": 3.5,
+        "y": 43.5,
         "shape": pin_holder,
         "height": 3,
     },
+    # Perimeter
+    {
+        "x": width / 2,
+        "y": height / 2,
+        "shape": (
+            cq.Sketch()
+            .trapezoid(width, height, 90, mode="a")
+            .trapezoid(width - 2, height - 2, 90, mode="s")
+            .vertices()
+            .fillet(3)
+        ),
+        "height": 0.2,
+    },
 ]
 
 
+vents = hex_vents(size=3, width=width, height=height)
+
+
 # Hole distances are relative to the rightmost pillar
 # seen from the back of the case, that's why they are negative
 # Heights are relative to base of pillars
@@ -56,18 +81,71 @@ elements = [
 holes = [
     # Power inlet
     {
-        "x": -15,
+        "x": -18,
         "y": -1 + pillar_height,
-        "height": 6.5,
-        "width": 12,
-        "fillet": 1,
+        "shape": cq.Sketch().trapezoid(12, 6.5, 90, mode="a").vertices().fillet(1),
     },
     # Power button
     {
-        "x": -67,
+        "x": -70,
         "y": 5.5 + pillar_height,
-        "height": 7,
-        "width": 7,
-        "fillet": 1,
+        "shape": cq.Sketch().trapezoid(7, 7, 90, mode="a").vertices().fillet(1),
     },
 ]
+
+
+def add(
+    *,
+    model,
+    width,
+    height,
+    thickness,
+    offset_x,
+    offset_y,
+    bottom_face,
+    back_face,
+    shell_t
+):
+
+    if bottom_face:
+        # Vents
+        for vent in vents:
+            model = punch_hole(
+                model=model,
+                face=bottom_face,
+                w=width,
+                h=height,
+                x_offset=offset_x + vent["x"],
+                y_offset=shell_t + offset_y + vent["y"],
+                hole=vent,
+                depth=shell_t,
+            )
+
+        # Battery holder stands and pogo pin holder
+        for element in elements:
+            model = extrude_shape(
+                model=model,
+                face=bottom_face,
+                w=width,
+                h=height,
+                x_offset=offset_x,
+                y_offset=shell_t + offset_y,
+                element=element,
+                height=-(element["height"] + shell_t),
+            )
+
+    if back_face:
+        # Holes
+        for hole in holes:
+            model = punch_hole(
+                model=model,
+                face=back_face,
+                w=width,
+                h=thickness,
+                x_offset=width - offset_x,
+                y_offset=shell_t,
+                hole=hole,
+                depth=shell_t,
+            )
+
+    return model

notebook_nueva/hdmi_out.py

@@ -0,0 +1,47 @@
+# Hole to expose a USB audio card (YMMV)
+
+import cadquery as cq
+
+from utils import punch_hole
+
+# The hole is for a random USB sound card.
+# Consumers should set proper offsets for the hole
+
+holes = [
+    # Hole for HDMI female adapter
+    {
+        "x": 0,
+        "y": 7,
+        "shape": cq.Sketch().trapezoid(22, 12.5, 90, mode="a").vertices().fillet(2),
+    },
+]
+
+
+def add(
+    *,
+    model,
+    width,
+    height,
+    thickness,
+    offset_x,
+    offset_y,
+    bottom_face,
+    back_face,
+    shell_t
+):
+
+    # Holes
+    if back_face:
+        for hole in holes:
+            model = punch_hole(
+                model=model,
+                face=back_face,
+                w=width,
+                h=thickness,
+                x_offset=width - offset_x,
+                y_offset=shell_t,
+                hole=hole,
+                depth=shell_t,
+            )
+
+    return model

notebook_nueva/keyboard.py

@@ -0,0 +1,103 @@
+import cadquery as cq
+import math
+
+# Size of the kbd board
+kbd_height = 95.5
+kbd_width = 305
+back_thickness = 19
+front_thickness = 12
+
+# Pythagoras
+actual_height = (kbd_height**2 - (back_thickness - front_thickness) ** 2) ** 0.5
+kbd_angle = math.acos(actual_height / kbd_height) * 180 / math.pi
+
+kbd_pillar_positions = [
+    (19, 16),
+    (142.5, 25.5),
+    (kbd_width - 20, 16),
+    (23.5, 79.5),
+    (145.5, 82.5),
+    (kbd_width - 19, 79.5),
+]
+
+elements = [
+    # Shorter pillars
+    {
+        "x": 0,
+        "y": 0,
+        "z": 5.5,
+        "shape": cq.Sketch().push(kbd_pillar_positions).circle(5, mode="a"),
+    },
+    # Taller pillars with holes for self-tapping screws
+    {
+        "x": 0,
+        "y": 0,
+        "z": 2.5,
+        "shape": (
+            cq.Sketch()
+            .push(kbd_pillar_positions)
+            .circle(2.4, mode="a")
+            .circle(1.1, mode="s")
+        ),
+    },
+]
+
+
+def add(
+    *,
+    model,
+    width,
+    height,
+    thickness,
+    offset_x,
+    offset_y,
+    bottom_face,
+    back_face,
+    shell_t
+):
+
+    # This one is special, it creates angled things and cuts off the
+    # case, so ... it's going to do weird stuff
+
+    if bottom_face:
+        model = (
+            model.faces(bottom_face)
+            .workplane(centerOption="CenterOfBoundBox", offset=-front_thickness)
+            .center(
+                -width / 2,
+                height / 2,
+            )
+            .transformed(rotate=cq.Vector(kbd_angle, 0, 0))
+            .tag("kbd_sloped")
+        )
+        for element in elements:
+            model = (
+                model.workplaneFromTagged("kbd_sloped")
+                .center(offset_x + element["x"], -offset_y - element["y"])
+                .workplane(offset=element["z"])
+                .placeSketch(element["shape"])
+                .extrude(100)
+            )
+
+        model = (
+            model.workplaneFromTagged("mid_height")
+            .transformed(offset=cq.Vector(0, 0, -thickness / 2))
+            .split(keepTop=True)
+            .faces(">X")
+            .workplane(centerOption="CenterOfBoundBox")
+            .center(-height / 2, -thickness / 2)
+            .placeSketch(
+                cq.Sketch().polygon(
+                    [
+                        [0, front_thickness],
+                        [actual_height, back_thickness],
+                        [actual_height, 1000],
+                        [0, 1000],
+                        [0, front_thickness],
+                    ]
+                )
+            )
+            .cutBlind(-1000)
+        )
+
+    return model

notebook_nueva/modelo.py

@@ -3,9 +3,11 @@ from cadquery import exporters
 
 import audio_plug
 import battery_holder
+import hdmi_out
+import keyboard
+import screen_pillars
 import usb_hub
 import zero_holder as cpu_holder
-from utils import extrude_shape, punch_hole
 
 # Base for the notebook. Basically a kbd base that extends back
 # as much as possible
@@ -27,70 +29,33 @@ thickness = 27 + shell_t  # 27 inside
 ti_radius = 2.35
 ti_depth = 6.25
 
-# Positions are determined by measuring the keyboard
-
-kbd_pillar_positions = [
-    (18.25, -16),
-    (142.5, -25.5),
-    (kbd_width - 20, -16),
-    (23.5, -79.5),
-    (145.5, -82.5),
-    (kbd_width - 19, -79.5),
-]
-
-
-# 2-level mounting pillars for the kbd
-# Width of these need to be tweaked for
-# each specific keyboard
-kbd_pillars = (
-    cq.Sketch()
-    .push(kbd_pillar_positions)
-    .circle(2.2, mode="a")
-    # Holes for self-tapping screws
-    .circle(1.1, mode="s")
-)
-
-kbd_lower_pillars = (
-    cq.Sketch()
-    .push(kbd_pillar_positions)
-    .circle(4, mode="a")
-    # Holes for self-tapping screws
-    .circle(1.1, mode="s")
-)
-
 # These are placed where convenient, and are used to join the top and bottom
 # parts of the case.
 # Measured from top-left corner OUTSIDE
 mounting_pillar_positions = [
-    (6, -6),
-    (6, -40),
-    (120, -6),
-    (170, -6),
-    (width - 6, -6),
-    (width - 6, -30),
+    (6, 6),
+    (6, 48),
+    (120, 6),
+    (170, 6),
+    (width - 6, 6),
+    (width - 6, 30),
+    (120, 48),
+    (170, 48),
 ]
-
-mounting_pillars = (
-    cq.Sketch()
-    .push(mounting_pillar_positions)
-    .trapezoid(12, 12, 90, mode="a")
-    .circle(1.8, mode="s")
-)
-
-screw_holes = cq.Sketch().push(mounting_pillar_positions).circle(3, mode="a")
+screen_pillars.init(mounting_pillar_positions, thickness - shell_t)
 
 # Thing to "grab" the hub so it stays in place
-# Distance from edge to center of USB plug
-usb_offset = 48
+# Distance from left edge to center of USB plug
+usb_offset = width - 48
 
 
 # CPU holder position from back-left corner of the case
-cpu_offset_x = 160
-cpu_offset_y = 25
+cpu_offset_x = 180
+cpu_offset_y = 3
 
 # Battery holder position from back-left corner of the case
-battery_offset_x = 22
-battery_offset_y = 8
+battery_offset_x = 15
+battery_offset_y = 3
 
 # Offset for the USB port from back-right corner of the case
 usb_offset = 48
@@ -98,10 +63,6 @@ usb_offset = 48
 
 def model():
     # Create the basic shape of the case bottom.
-
-    # Currently also adds keyboard stuff and things to connect
-    # to the screen case, but that should be refactored
-    # out (FIXME)
     model = (
         cq.Workplane("XY")
         .workplane(offset=thickness / 2)
@@ -112,138 +73,112 @@ def model():
         .fillet(2)
         .faces(">Z")
         .shell(-shell_t)
-        # Slanted mounting pillars on the kbd top
-        .faces(">Z")
-        .workplane(centerOption="CenterOfBoundBox")
-        # Top-left kbd corner inside the box
-        .center(-width / 2 + shell_t, kbd_height - height / 2 + shell_t)
-        .transformed(rotate=cq.Vector(kbd_angle, 0, 0))
-        # These two offsets push the keyboard "down" into the case
-        # and need to be adjusted per-keyboard
-        .tag("sloped")
-        .workplane(offset=-2.5)
-        .placeSketch(kbd_pillars)
-        .extrude(-1000)
-        .workplaneFromTagged("sloped")
-        .workplane(offset=-5.5)
-        .placeSketch(kbd_lower_pillars)
-        .extrude(-1000)
-        # Remove the excess extrusion
-        .workplaneFromTagged("mid_height")
-        .transformed(offset=cq.Vector(0, 0, -thickness / 2))
-        .split(keepTop=True)
-        # Slope for the beyboard
-        .workplaneFromTagged("sloped")
-        .split(keepBottom=True)
-        # Pillars to join with top half
-        .workplaneFromTagged("mid_height")
-        .workplane(offset=-thickness / 2, centerOption="CenterOfBoundBox")
-        .center(-width / 2, height / 2)
-        .placeSketch(mounting_pillars)
-        .extrude(thickness)
-        # Holes to insert screws from the bottom
-        .workplaneFromTagged("mid_height")
-        .workplane(offset=-thickness / 2, centerOption="CenterOfBoundBox")
-        .center(-width / 2, height / 2)
-        .placeSketch(screw_holes)
-        # 13 is 20-7 (screw thread length - threaded insert depth)
-        .cutBlind(thickness - 13)
     )
 
     # Now the basic box shape is in place, start adding things
     # and cutting holes.
 
-    # Holes in the back of the case for battery holder
-    for hole in battery_holder.holes:
-        model = punch_hole(
-            model=model,
-            face=">Y",
-            w=width,
-            h=thickness,
-            x_offset=width - battery_offset_x,
-            y_offset=shell_t,
-            hole=hole,
-            depth=shell_t,
-        )
-
-    # Hole for USB hub in the back
-    for hole in usb_hub.holes:
-        model = punch_hole(
-            model=model,
-            face=">Y",
-            w=width,
-            h=thickness,
-            x_offset=usb_offset + shell_t + usb_hub.holes[0]["width"] / 2,
-            y_offset=shell_t,
-            hole=hole,
-            depth=shell_t,
-        )
-
-    # USB hub holder
-    for element in usb_hub.elements:
-        model = extrude_shape(
-            model=model,
-            face="<Z",
-            w=width,
-            h=height,
-            x_offset=width - usb_offset - shell_t - +usb_hub.holes[0]["width"] / 2,
-            y_offset=shell_t + element["y"],
-            shape=element["shape"],
-            height=-(element["height"] + shell_t),
-        )
+    model = usb_hub.add(
+        model=model,
+        width=width,
+        height=height,
+        thickness=thickness,
+        bottom_face="<Z",
+        back_face=">Y",
+        offset_x=width - usb_offset,
+        offset_y=0,
+        shell_t=shell_t,
+    )
 
     # Hole for audio in right side
-    for hole in audio_plug.holes:
-        model = punch_hole(
-            model=model,
-            face=">X",
-            w=height,
-            h=thickness,
-            x_offset=height - shell_t - 34.5 - audio_plug.holes[0]["width"] / 2,
-            y_offset=shell_t,
-            hole=hole,
-            depth=shell_t,
-        )
+    model = audio_plug.add(
+        model=model,
+        width=width,
+        height=height,
+        thickness=thickness,
+        offset_x=111,  # Offset from the front-left corner
+        offset_y=0,  # Offset from the bottom
+        bottom_face=None,
+        back_face=">X",
+        shell_t=shell_t,
+    )
 
-    # Battery holder stands and pogo pin holder
-    for element in battery_holder.elements:
-        model = extrude_shape(
-            model=model,
-            face="<Z",
-            w=width,
-            h=height,
-            x_offset=battery_offset_x + element["x"],
-            y_offset=shell_t + battery_offset_y + element["y"],
-            shape=element["shape"],
-            height=-(element["height"] + shell_t),
-        )
+    # Hole for HDMI out in the back
+    model = hdmi_out.add(
+        model=model,
+        width=width,
+        height=height,
+        thickness=thickness,
+        offset_x=138,
+        offset_y=0,
+        bottom_face=None,
+        back_face=">Y",
+        shell_t=shell_t,
+    )
 
-    # CPU holder stands
-    for element in cpu_holder.elements:
-        model = extrude_shape(
-            model=model,
-            face="<Z",
-            w=width,
-            h=height,
-            x_offset=cpu_offset_x + element["x"],
-            y_offset=shell_t + cpu_offset_y + element["y"],
-            shape=element["shape"],
-            height=-(element["height"] + shell_t),
-        )
+    model = cpu_holder.add(
+        model=model,
+        width=width,
+        height=height,
+        thickness=thickness,
+        offset_x=cpu_offset_x,
+        offset_y=cpu_offset_y,
+        bottom_face="<Z",
+        back_face=None,  # Not exposing the holes
+        shell_t=shell_t,
+    )
+
+    # This adds all the holes and extrusions for the battery system
+    model = battery_holder.add(
+        model=model,
+        width=width,
+        height=height,
+        thickness=thickness,
+        offset_x=battery_offset_x,
+        offset_y=battery_offset_y,
+        bottom_face="<Z",
+        back_face=">Y",
+        shell_t=shell_t,
+    )
+
+    model = screen_pillars.add(
+        model=model,
+        width=width,
+        height=height,
+        thickness=thickness,
+        offset_x=0,
+        offset_y=0,
+        bottom_face="<Z",
+        back_face=None,
+        shell_t=shell_t,
+    )
+
+    model = keyboard.add(
+        model=model,
+        width=width,
+        height=height,
+        thickness=thickness,
+        bottom_face="<Z",
+        back_face=None,
+        offset_x=shell_t,
+        offset_y=kbd_height + shell_t,
+        shell_t=shell_t,
+    )
 
     return model
 
 
 if __name__ == "__main__":
 
+    model = model()
+
     left_cutout = cq.Sketch().polygon(
         [(0, 0), (width / 2, 0), (width / 2, -height), (0, -height), (0, 0)],
         mode="a",
     )
 
     right_side = (
-        model()
-        .faces("<Z")
+        model.faces("<Z")
         .workplaneFromTagged("mid_height")
         .transformed(offset=cq.Vector(0, 0, -thickness / 2))
         .center(-width / 2, height / 2)
@@ -265,8 +200,7 @@ if __name__ == "__main__":
     )
 
     left_side = (
-        model()
-        .faces("<Z")
+        model.faces("<Z")
         .workplaneFromTagged("mid_height")
         .transformed(offset=cq.Vector(0, 0, -thickness / 2))
         .center(-width / 2, height / 2)
@@ -275,4 +209,4 @@ if __name__ == "__main__":
     )
     exporters.export(left_side, "left_side.stl")
 
-    exporters.export(model(), "model.stl")
+    exporters.export(model, "model.stl")

notebook_nueva/screen_mount.py

@@ -42,6 +42,9 @@ board_cutout = cq.Sketch().trapezoid(
 
 kbd_cable_hole = cq.Sketch().trapezoid(20, 9, 90, mode="a").vertices().fillet(1)
 
+# y needs to be inverted because this is the top side, adn there's 2 pillars we don't use
+mounting_pillar_positions = [(x, -y) for x, y in mounting_pillar_positions[:-2]]
+
 mounting_pillars = (
     cq.Sketch()
     .push(mounting_pillar_positions)

notebook_nueva/screen_pillars.py

@@ -0,0 +1,76 @@
+from utils import extrude_shape, punch_hole
+import cadquery as cq
+
+elements = None
+bottom_holes = None  # Not really vents FIXME
+
+
+def init(positions, thickness):
+    """Because these need to match in multiple models, we create the
+    elemments dynamically"""
+    global elements, bottom_holes
+    elements = [
+        {
+            "x": 0,
+            "y": 0,
+            "shape": cq.Sketch().push(positions).trapezoid(12, 12, 90, mode="a"),
+            "height": thickness,
+        }
+    ]
+
+    bottom_holes = [
+        {
+            "x": 0,
+            "y": 0,
+            "shape": cq.Sketch().push(positions).circle(3, mode="a"),
+            "depth": thickness - 13,  # (screw thread length - threaded insert depth)
+        },
+        {
+            "x": 0,
+            "y": 0,
+            "shape": cq.Sketch().push(positions).circle(1.8, mode="a"),
+            "depth": 100,
+        },
+    ]
+
+
+def add(
+    *,
+    model,
+    width,
+    height,
+    thickness,
+    offset_x,
+    offset_y,
+    bottom_face,
+    back_face,
+    shell_t
+):
+    if bottom_face:
+
+        # Mounting pillars
+        for element in elements:
+            model = extrude_shape(
+                model=model,
+                face=bottom_face,
+                w=width,
+                h=height,
+                x_offset=offset_x,
+                y_offset=shell_t + offset_y,
+                element=element,
+                height=-(element["height"] + shell_t),
+            )
+        # Screw holes
+        for hole in bottom_holes:
+            model = punch_hole(
+                model=model,
+                face=bottom_face,
+                w=width,
+                h=height,
+                x_offset=offset_x,
+                y_offset=shell_t + offset_y,
+                hole=hole,
+                depth=hole["depth"],
+            )
+
+    return model

notebook_nueva/usb_hub.py

@@ -1,5 +1,7 @@
 import cadquery as cq
 
+from utils import punch_hole, extrude_shape
+
 # Measurements for my USB hub, YMMV
 
 # The hole is for a USB-A plug, y is measured in the hub
@@ -11,9 +13,7 @@ holes = [
     {
         "x": 0,
         "y": 4,
-        "height": 5.5,
-        "width": 13,
-        "fillet": 2,
+        "shape": cq.Sketch().trapezoid(13, 5, 90, mode="a").vertices().fillet(2),
     },
 ]
 
@@ -23,11 +23,52 @@ elements = [
         "x": 0,
         "y": 5,
         "shape": (
-            cq.Sketch()
-            .trapezoid(22, 10, 90, mode="a")
-            .trapezoid(17, 10, 90, mode="s")
-            .clean()
+            cq.Sketch().trapezoid(22, 10, 90, mode="a").trapezoid(17, 10, 90, mode="s")
         ),
         "height": 8,
     }
 ]
+
+
+def add(
+    *,
+    model,
+    width,
+    height,
+    thickness,
+    offset_x,
+    offset_y,
+    bottom_face,
+    back_face,
+    shell_t
+):
+
+    # USB Hub extrusions
+    if bottom_face:
+        for element in elements:
+            model = extrude_shape(
+                model=model,
+                face=bottom_face,
+                w=width,
+                h=height,
+                x_offset=263,  # offset_x,
+                y_offset=0,  # shell_t + offset_y,
+                element=element,
+                height=-(element["height"] + shell_t),
+            )
+
+    # Holes
+    if back_face:
+        for hole in holes:
+            model = punch_hole(
+                model=model,
+                face=back_face,
+                w=width,
+                h=thickness,
+                x_offset=width - offset_x,
+                y_offset=shell_t,
+                hole=hole,
+                depth=shell_t,
+            )
+
+    return model

notebook_nueva/utils.py

@@ -1,12 +1,13 @@
 import cadquery as cq
+from math import floor
 
-# TODO make API of extrude_shape and punch_hole more consistent
-def extrude_shape(*, model, face, w, h, x_offset, y_offset, shape, height):
+
+def extrude_shape(*, model, face, w, h, x_offset, y_offset, element, height):
     return (
         model.faces(face)
         .workplane(centerOption="CenterOfBoundBox")
-        .center(-w / 2 + x_offset, -h / 2 + y_offset)
-        .placeSketch(shape)
+        .center(-w / 2 + x_offset + element["x"], -h / 2 + y_offset + element["y"])
+        .placeSketch(element["shape"])
         .extrude(height)
     )
 
@@ -16,11 +17,57 @@ def punch_hole(*, model, face, w, h, x_offset, y_offset, hole, depth):
         model.faces(face)
         .workplane(centerOption="CenterOfBoundBox")
         .center(-w / 2 + x_offset + hole["x"], -h / 2 + y_offset + hole["y"])
-        .placeSketch(
-            cq.Sketch()
-            .trapezoid(hole["width"], hole["height"], 90, mode="a")
-            .vertices()
-            .fillet(hole["fillet"])
-        )
+        .placeSketch(hole["shape"])
         .cutBlind(-depth)
     )
+
+
+def extrude_shape2(*, model, face, w, h, x_offset, y_offset, hole, depth):
+    return (
+        model.faces(face)
+        .workplane(centerOption="CenterOfBoundBox")
+        .center(-w / 2 + x_offset + hole["x"], -h / 2 + y_offset + hole["y"])
+        .placeSketch(hole["shape"])
+        .extrude(-depth)
+    )
+
+
+def hex_vents(*, size, width, height):
+    # size is radius of the hexagon
+    # Information about how this works:
+    # https://www.redblobgames.com/grids/hexagons/
+
+    x_step = size * (3**0.5)
+    y_step = size * 3 / 2
+
+    x_count = floor(width / x_step) - 1
+
+    if height > 4 * size:
+        y_count = floor((height - 2 * size) / (1.5 * size))
+    else:
+        y_count = 1
+
+    x_size = (x_count + 0.5) * x_step  # Assumes at least 2 rows
+    y_size = 2 * size + 1.5 * size * (y_count - 1)
+
+    x_offset = (width - x_size) / 2 + 0.5 * x_step
+    y_offset = (height - y_size) / 2 + size
+
+    vent_positions = []
+    for x in range(0, x_count):
+        for y in range(0, y_count):
+            vent_positions.append(
+                (
+                    (x + (y % 2) / 2) * x_step + x_offset,
+                    y * y_step + y_offset,
+                )
+            )
+    vents = [
+        {
+            "x": 0,
+            "y": 0,
+            "shape": cq.Sketch().push(vent_positions).regularPolygon(size * 0.85, 6),
+        }
+    ]
+
+    return vents

notebook_nueva/zero_holder.py

@@ -1,10 +1,18 @@
 import cadquery as cq
 
-positions = [(0, 0), (0, 23), (58, 23), (58, 0)]
+from utils import extrude_shape, punch_hole, hex_vents
 
-stands = cq.Sketch().push(positions).circle(3, mode="a").circle(2.65 / 2, mode="s")
+width = 65
+height = 30
 pillar_height = 7
 
+stand_positions = [(3.5, 3.5), (3.5, 26.5), (61.5, 26.5), (61.5, 3.5)]
+
+stands = (
+    cq.Sketch().push(stand_positions).circle(3, mode="a").circle(2.65 / 2, mode="s")
+)
+
+
 elements = [
     # CPU holder stands
     {
@@ -12,5 +20,92 @@ elements = [
         "y": 0,
         "shape": stands,
         "height": pillar_height,
+    },
+    {
+        "x": 0,
+        "y": 0,
+        "shape": cq.Sketch().push(stand_positions).circle(5),
+        "height": 0,
+    },
+    # Perimeter
+    {
+        "x": width / 2,
+        "y": height / 2,
+        "shape": (
+            cq.Sketch()
+            .trapezoid(width, height, 90, mode="a")
+            .trapezoid(width - 2, height - 2, 90, mode="s")
+            .vertices()
+            .fillet(3)
+        ),
+        "height": 0.2,
+    },
+]
+
+vents = hex_vents(size=3, width=width, height=height)
+
+holes = [
+    # One hole for everything TODO: improve
+    {
+        "x": -width / 2,
+        "y": 1 + pillar_height,
+        "shape": cq.Sketch().trapezoid(50, 6, 90, mode="a").vertices().fillet(1),
     }
 ]
+
+
+def add(
+    *,
+    model,
+    width,
+    height,
+    thickness,
+    offset_x,
+    offset_y,
+    bottom_face,
+    back_face,
+    shell_t
+):
+
+    if bottom_face:
+        # Vents
+        for vent in vents:
+            model = punch_hole(
+                model=model,
+                face=bottom_face,
+                w=width,
+                h=height,
+                x_offset=offset_x + vent["x"],
+                y_offset=shell_t + offset_y + vent["y"],
+                hole=vent,
+                depth=shell_t,
+            )
+
+        # CPU holder extrusions
+        for element in elements:
+            model = extrude_shape(
+                model=model,
+                face=bottom_face,
+                w=width,
+                h=height,
+                x_offset=offset_x,
+                y_offset=shell_t + offset_y,
+                element=element,
+                height=-(element["height"] + shell_t),
+            )
+
+    # Holes
+    if back_face:
+        for hole in holes:
+            model = punch_hole(
+                model=model,
+                face=back_face,
+                w=width,
+                h=thickness,
+                x_offset=width - offset_x,
+                y_offset=shell_t,
+                hole=hole,
+                depth=shell_t,
+            )
+
+    return model