comment

This cut is not needed with the lower keyboard position.

notebook_nueva/audio_plug.py

@@ -0,0 +1,16 @@
+# 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)
+# Consumers should set proper offsets for the hole
+
+holes = [
+    # 2-jack plug
+    {
+        "x": 0,
+        "y": 4,
+        "height": 6,
+        "width": 17,
+        "fillet": 2,
+    },
+]

notebook_nueva/battery_holder.py

@@ -0,0 +1,73 @@
+import cadquery as cq
+
+stand_positions = [(0, 0), (58, 0), (58, 49), (0, 49)]
+stands = (
+    cq.Sketch().push(stand_positions).circle(3, mode="a").circle(2.65 / 2, mode="s")
+)
+pillar_height = 7
+
+
+# This is a holder for DuPont cables so they connect to this
+# things' pogo pins which are used to power the CPU
+pin_positions = [(3.5, 0), (4 * 2.54 + 3.5, 0)]
+pin_holder_width = 25
+pin_holder_height = 15
+pin_holder = (
+    cq.Sketch()
+    .polygon(
+        [
+            (0.5, 0),
+            (pin_holder_width, 0),
+            (pin_holder_width, pin_holder_height),
+            (0, pin_holder_height),
+            (0.5, 0),
+        ],
+        mode="a",
+    )
+    .push(pin_positions)
+    .polygon(
+        [(0, 0), (2.6, 0), (2.6, pin_holder_height), (0, pin_holder_height), (0, 0)],
+        mode="s",
+    )
+)
+
+elements = [
+    # Battery holder stands
+    {
+        "x": 0,
+        "y": 0,
+        "shape": stands,
+        "height": pillar_height,
+    },
+    # Pogo pin connector channels
+    {
+        "x": 0,
+        "y": 40,
+        "shape": pin_holder,
+        "height": 3,
+    },
+]
+
+
+# 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
+# All distances are measured to the CENTER of the hole
+holes = [
+    # Power inlet
+    {
+        "x": -15,
+        "y": -1 + pillar_height,
+        "height": 6.5,
+        "width": 12,
+        "fillet": 1,
+    },
+    # Power button
+    {
+        "x": -67,
+        "y": 5.5 + pillar_height,
+        "height": 7,
+        "width": 7,
+        "fillet": 1,
+    },
+]

notebook_nueva/modelo.py

@@ -1,43 +1,108 @@
-import cadquery2 as cq
+import cadquery as cq
-from cadquery2 import exporters
+from cadquery import exporters
+
+import audio_plug
+import battery_holder
+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
 
-# Size of the whole object
-width = 295
-height = 165
-thickness = 25
-
-kbd_height = 100
-kbd_angle = 6
-
 # Thickness of the outer material
 shell_t = 3
 
+# Size of the kbd board
+kbd_height = 95.5
+kbd_width = 305
+kbd_angle = 5
+
+# Size of the whole object
+width = kbd_width + 2 * shell_t
+height = 159
+thickness = 27 + shell_t  # 27 inside
+
 # Insert Positions
 ti_radius = 2.35
 ti_depth = 6.25
 
-pillars = (
+# 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(
+    .push(kbd_pillar_positions)
-        [
+    .circle(2.2, mode="a")
-            (19, -16.5),
+    # Holes for self-tapping screws
-            (133, -16.5),
+    .circle(1.1, mode="s")
-            (247.5, -16.5),
-            (24, -86),
-            (142.5, -91),
-            (261.5, -86),
-        ]
-    )
-    .trapezoid(12, 12, 90, mode="a")
-    .circle(ti_radius, 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),
+]
+
+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")
+
+# Thing to "grab" the hub so it stays in place
+# Distance from edge to center of USB plug
+usb_offset = 48
+
+
+# CPU holder position from back-left corner of the case
+cpu_offset_x = 160
+cpu_offset_y = 25
+
+# Battery holder position from back-left corner of the case
+battery_offset_x = 22
+battery_offset_y = 8
+
+# Offset for the USB port from back-right corner of the case
+usb_offset = 48
+
 
 def model():
-    return (
+    # 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)
         .tag("mid_height")
@@ -50,10 +115,18 @@ def model():
         # Slanted mounting pillars on the kbd top
         .faces(">Z")
         .workplane(centerOption="CenterOfBoundBox")
-        .center(-width / 2, 17)
+        # 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")
-        .placeSketch(pillars)
+        .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")
@@ -62,41 +135,144 @@ def model():
         # 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)
     )
 
-top_right = (
+    # Now the basic box shape is in place, start adding things
-    model()
+    # and cutting holes.
-    .faces(">Y")
-    .workplane(offset = -120).split(keepTop=True)
-    .faces(">X")
-    .workplane(offset=-135).split(keepTop=True)
-)
-exporters.export(top_right, "top_right.stl")
 
-top_left = (
+    # Holes in the back of the case for battery holder
-    model()
+    for hole in battery_holder.holes:
-    .faces(">Y")
+        model = punch_hole(
-    .workplane(offset = -120).split(keepTop=True)
+            model=model,
-    .faces(">X")
+            face=">Y",
-    .workplane(offset=-135).split(keepBottom=True)
+            w=width,
-)
+            h=thickness,
-exporters.export(top_left, "top_left.stl")
+            x_offset=width - battery_offset_x,
+            y_offset=shell_t,
+            hole=hole,
+            depth=shell_t,
+        )
 
-bottom_right = (
+    # Hole for USB hub in the back
-    model()
+    for hole in usb_hub.holes:
-    .faces(">Y")
+        model = punch_hole(
-    .workplane(offset = -120).split(keepBottom=True)
+            model=model,
-    .faces(">X")
+            face=">Y",
-    .workplane(offset=-165).split(keepTop=True)
+            w=width,
-)
+            h=thickness,
-exporters.export(bottom_right, "bottom_right.stl")
+            x_offset=usb_offset + shell_t + usb_hub.holes[0]["width"] / 2,
+            y_offset=shell_t,
+            hole=hole,
+            depth=shell_t,
+        )
 
-bottom_left = (
+    # USB hub holder
-    model()
+    for element in usb_hub.elements:
-    .faces(">Y")
+        model = extrude_shape(
-    .workplane(offset = -120).split(keepBottom=True)
+            model=model,
-    .faces(">X")
+            face="<Z",
-    .workplane(offset=-165).split(keepBottom=True)
+            w=width,
-)
+            h=height,
-exporters.export(bottom_left, "bottom_left.stl")
+            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),
+        )
 
+    # 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,
+        )
+
+    # 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),
+        )
+
+    # 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),
+        )
+
+    return model
+
+
+if __name__ == "__main__":
+
+    left_cutout = cq.Sketch().polygon(
+        [(0, 0), (width / 2, 0), (width / 2, -height), (0, -height), (0, 0)],
+        mode="a",
+    )
+
+    right_side = (
+        model()
+        .faces("<Z")
+        .workplaneFromTagged("mid_height")
+        .transformed(offset=cq.Vector(0, 0, -thickness / 2))
+        .center(-width / 2, height / 2)
+        .placeSketch(left_cutout)
+        .cutBlind(100)
+    )
+
+    exporters.export(right_side, "right_side.stl")
+
+    right_cutout = cq.Sketch().polygon(
+        [
+            (width / 2, 0),
+            (width, 0),
+            (width, -height),
+            (width / 2, -height),
+            (width / 2, 0),
+        ],
+        mode="a",
+    )
+
+    left_side = (
+        model()
+        .faces("<Z")
+        .workplaneFromTagged("mid_height")
+        .transformed(offset=cq.Vector(0, 0, -thickness / 2))
+        .center(-width / 2, height / 2)
+        .placeSketch(right_cutout)
+        .cutBlind(100)
+    )
+    exporters.export(left_side, "left_side.stl")
+
+    exporters.export(model(), "model.stl")

notebook_nueva/screen_mount.py

@@ -0,0 +1,154 @@
+import cadquery as cq
+from cadquery import exporters
+
+from modelo import (
+    kbd_height,
+    kbd_width,
+    mounting_pillar_positions,
+    shell_t,
+    ti_depth,
+    ti_radius,
+)
+
+# Size of the whole object
+width = kbd_width + 2 * shell_t
+height = 66
+height_bottom = 59
+thickness = 48  # Will be shorter after construction
+
+# Visible screen size
+vis_w = 219
+vis_h = 55
+viewport_cutout = cq.Sketch().trapezoid(vis_w, vis_h, 90, mode="a").vertices().fillet(2)
+
+# Whole screen size
+scr_w = 231
+scr_h = 65
+scr_thickness = 5.5
+screen_cutout = cq.Sketch().trapezoid(scr_w, scr_h, 90, mode="a")
+
+# Screen angle
+scr_angle = 20
+
+# Circuit board and cable hole.
+# This is in the back of the screen, and is a bit shorter in height than the
+# screen. It's wider so it removes enough material to make the shape simpler.
+board_cutout = cq.Sketch().trapezoid(
+    scr_w + 5,
+    scr_h - 10,
+    90,
+    mode="a",
+)
+
+kbd_cable_hole = cq.Sketch().trapezoid(20, 9, 90, mode="a").vertices().fillet(1)
+
+mounting_pillars = (
+    cq.Sketch()
+    .push(mounting_pillar_positions)
+    .trapezoid(-12, 12, 90, mode="a")
+    .circle(ti_radius, mode="s")
+    .clean()
+)
+
+
+def model():
+    return (
+        cq.Workplane("XY")
+        .workplane()
+        .tag("mid_height")
+        .box(width, height, thickness)
+        # The screen goes rotated
+        .faces(">Z")
+        .transformed(rotate=(scr_angle, 0, 0))
+        # Move the screen "lower" so it doesn't interfere
+        # so much with the back
+        .center(0, -2)
+        .tag("slanted")
+        # Arbitrary huge trapezoid to cut off the material *in front*
+        # of the inclined screen
+        .placeSketch(cq.Sketch().trapezoid(1000, 1000, 90, mode="a"))
+        .cutBlind(1000)
+        # Trim the top
+        .workplaneFromTagged("mid_height")
+        .workplane(offset=21)
+        .placeSketch(cq.Sketch().trapezoid(1000, 1000, 90, mode="a"))
+        .cutBlind(100)
+        # Make bottom smaller to fit with base
+        .faces(">X")
+        .workplane(centerOption="CenterOfBoundBox")
+        .center(-height / 2, -thickness / 2)
+        .placeSketch(
+            cq.Sketch()
+            .polygon(
+                [
+                    (height_bottom, 0),
+                    (height_bottom, thickness / 3),
+                    (height, thickness - 21),
+                    (height, thickness),
+                    (height + 5, thickness + 5),
+                    (height + 5, 0),
+                    (height_bottom, 0),
+                ]
+            )
+            .vertices()
+            .fillet(3)
+        )
+        .cutBlind(-1000)
+        # Fillet top of the object
+        .edges("|X and >Z")
+        .fillet(3)
+        # Cut off viewport hole so we can see the screen
+        .workplaneFromTagged("slanted")
+        .placeSketch(viewport_cutout)
+        .cutBlind(-shell_t)
+        # Make hole for screen assembly so the whole screen fits
+        .workplaneFromTagged("slanted")
+        .workplane(offset=-shell_t, centerOption="CenterOfBoundBox")
+        # Left bezel is wider than right one, so this hole is displaced to the left
+        .center(-3, 0)
+        .placeSketch(screen_cutout)
+        .cutBlind(-scr_thickness)
+        # Make it hollow
+        .faces("<Z")
+        # Can't be exactly shell_t because cq fails
+        .shell(-shell_t + 0.01)
+        # Cut hole for the screen board and cables
+        .workplaneFromTagged("slanted")
+        .workplane(offset=-scr_thickness, centerOption="CenterOfBoundBox")
+        .placeSketch(board_cutout)
+        .cutBlind(-6)
+        .workplaneFromTagged("mid_height")
+        .workplane(offset=-thickness / 2, centerOption="CenterOfBoundBox")
+        .center(-width / 2, height_bottom - height / 2)
+        .placeSketch(mounting_pillars)
+        .extrude(10)
+        # Fillet the front edge of the screen case so it looks softer
+        .edges(">(0, -10, 5)")
+        .fillet(2)
+    )
+
+
+if __name__ == "__main__":
+
+    print("Exporting")
+    exporters.export(model(), "screen_mount.stl")
+
+    offset_width = -width / 2
+
+    right_side = (
+        model()
+        .faces(">X")
+        .workplane(centerOption="CenterOfBoundBox", offset=offset_width)
+        .split(keepTop=True)
+    )
+
+    exporters.export(right_side, "right_screen_mount.stl")
+
+    left_side = (
+        model()
+        .faces(">X")
+        .workplane(centerOption="CenterOfBoundBox", offset=offset_width)
+        .split(keepBottom=True)
+    )
+
+    exporters.export(left_side, "left_screen_mount.stl")

notebook_nueva/usb_hub.py

@@ -0,0 +1,33 @@
+import cadquery as cq
+
+# Measurements for my USB hub, YMMV
+
+# The hole is for a USB-A plug, y is measured in the hub
+# (from the bottom face to middle of the hole)
+# Consumers should set proper offsets for the hole
+
+holes = [
+    # USB-A port
+    {
+        "x": 0,
+        "y": 4,
+        "height": 5.5,
+        "width": 13,
+        "fillet": 2,
+    },
+]
+
+elements = [
+    # Thing to grab the hub
+    {
+        "x": 0,
+        "y": 5,
+        "shape": (
+            cq.Sketch()
+            .trapezoid(22, 10, 90, mode="a")
+            .trapezoid(17, 10, 90, mode="s")
+            .clean()
+        ),
+        "height": 8,
+    }
+]

notebook_nueva/utils.py

@@ -0,0 +1,26 @@
+import cadquery as cq
+
+# TODO make API of extrude_shape and punch_hole more consistent
+def extrude_shape(*, model, face, w, h, x_offset, y_offset, shape, height):
+    return (
+        model.faces(face)
+        .workplane(centerOption="CenterOfBoundBox")
+        .center(-w / 2 + x_offset, -h / 2 + y_offset)
+        .placeSketch(shape)
+        .extrude(height)
+    )
+
+
+def punch_hole(*, 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(
+            cq.Sketch()
+            .trapezoid(hole["width"], hole["height"], 90, mode="a")
+            .vertices()
+            .fillet(hole["fillet"])
+        )
+        .cutBlind(-depth)
+    )

notebook_nueva/zero_holder.py

@@ -0,0 +1,16 @@
+import cadquery as cq
+
+positions = [(0, 0), (0, 23), (58, 23), (58, 0)]
+
+stands = cq.Sketch().push(positions).circle(3, mode="a").circle(2.65 / 2, mode="s")
+pillar_height = 7
+
+elements = [
+    # CPU holder stands
+    {
+        "x": 0,
+        "y": 0,
+        "shape": stands,
+        "height": pillar_height,
+    }
+]

requirements.txt

@@ -1 +1 @@
-cadquery
+cadquery2