Parametric Hardware Library from Engineering Standards

import cadquery as cq
import math
import os

# ─── ISO Metric Thread Data (ISO 261) ───
THREAD_DATA = {
    "M3":  {"d": 3.0,  "P": 0.50},
    "M4":  {"d": 4.0,  "P": 0.70},
    "M5":  {"d": 5.0,  "P": 0.80},
    "M6":  {"d": 6.0,  "P": 1.00},
    "M8":  {"d": 8.0,  "P": 1.25},
    "M10": {"d": 10.0, "P": 1.50},
    "M12": {"d": 12.0, "P": 1.75},
    "M14": {"d": 14.0, "P": 2.00},
    "M16": {"d": 16.0, "P": 2.00},
    "M20": {"d": 20.0, "P": 2.50},
}

# ─── ISO 4014: Hex Bolt Head Dimensions ───
HEX_BOLT_DATA = {
    "M3":  {"s": 5.5,  "k": 2.0,  "b": 12},
    "M4":  {"s": 7.0,  "k": 2.8,  "b": 14},
    "M5":  {"s": 8.0,  "k": 3.5,  "b": 16},
    "M6":  {"s": 10.0, "k": 4.0,  "b": 18},
    "M8":  {"s": 13.0, "k": 5.3,  "b": 22},
    "M10": {"s": 16.0, "k": 6.4,  "b": 26},
    "M12": {"s": 18.0, "k": 7.5,  "b": 30},
    "M14": {"s": 21.0, "k": 8.8,  "b": 34},
    "M16": {"s": 24.0, "k": 10.0, "b": 38},
    "M20": {"s": 30.0, "k": 12.5, "b": 46},
}

# ─── ISO 4762: Socket Head Cap Screw Dimensions ───
SOCKET_CAP_DATA = {
    "M3":  {"dk": 5.5,  "k": 3.0,  "s_hex": 2.5},
    "M4":  {"dk": 7.0,  "k": 4.0,  "s_hex": 3.0},
    "M5":  {"dk": 8.5,  "k": 5.0,  "s_hex": 4.0},
    "M6":  {"dk": 10.0, "k": 6.0,  "s_hex": 5.0},
    "M8":  {"dk": 13.0, "k": 8.0,  "s_hex": 6.0},
    "M10": {"dk": 16.0, "k": 10.0, "s_hex": 8.0},
    "M12": {"dk": 18.0, "k": 12.0, "s_hex": 10.0},
    "M14": {"dk": 21.0, "k": 14.0, "s_hex": 12.0},
    "M16": {"dk": 24.0, "k": 16.0, "s_hex": 14.0},
    "M20": {"dk": 30.0, "k": 20.0, "s_hex": 17.0},
}

# ─── ISO 4032: Hex Nut Dimensions ───
HEX_NUT_DATA = {
    "M3":  {"s": 5.5,  "e": 6.01,  "m": 2.4},
    "M4":  {"s": 7.0,  "e": 7.66,  "m": 3.2},
    "M5":  {"s": 8.0,  "e": 8.79,  "m": 4.7},
    "M6":  {"s": 10.0, "e": 11.05, "m": 5.2},
    "M8":  {"s": 13.0, "e": 14.38, "m": 6.8},
    "M10": {"s": 16.0, "e": 17.77, "m": 8.4},
    "M12": {"s": 18.0, "e": 20.03, "m": 10.8},
    "M14": {"s": 21.0, "e": 23.36, "m": 12.8},
    "M16": {"s": 24.0, "e": 26.75, "m": 14.8},
    "M20": {"s": 30.0, "e": 33.53, "m": 18.0},
}

# ─── ISO 7089: Flat Washer Dimensions ───
WASHER_DATA = {
    "M3":  {"d1": 3.2,  "d2": 7.0,   "h": 0.5},
    "M4":  {"d1": 4.3,  "d2": 9.0,   "h": 0.8},
    "M5":  {"d1": 5.3,  "d2": 10.0,  "h": 1.0},
    "M6":  {"d1": 6.4,  "d2": 12.0,  "h": 1.6},
    "M8":  {"d1": 8.4,  "d2": 16.0,  "h": 1.6},
    "M10": {"d1": 10.5, "d2": 20.0,  "h": 2.0},
    "M12": {"d1": 13.0, "d2": 24.0,  "h": 2.5},
    "M14": {"d1": 15.0, "d2": 28.0,  "h": 2.5},
    "M16": {"d1": 17.0, "d2": 30.0,  "h": 3.0},
    "M20": {"d1": 21.0, "d2": 37.0,  "h": 3.0},
}

def make_thread(diameter, pitch, length, external=True):
    """
    Generate an ISO metric thread using a helical sweep.

    Parameters:
        diameter (float): Nominal diameter in mm (e.g., 6.0 for M6)
        pitch (float): Thread pitch in mm (e.g., 1.0 for M6 coarse)
        length (float): Thread length in mm
        external (bool): True for bolt thread, False for nut thread

    Returns:
        cq.Workplane: CadQuery solid of the threaded cylinder
    """
    # Fundamental triangle height (ISO 68-1)
    H = (math.sqrt(3) / 2.0) * pitch

    # Thread cross-section parameters
    if external:
        # External thread (bolt): major diameter = nominal
        d_major = diameter
        d_minor = diameter - 2 * (5/8) * H
        # Simplified: create thread as a helical cut on a cylinder
        thread_depth = (5/8) * H
    else:
        # Internal thread (nut): minor diameter = nominal - 2*(5/8)*H
        d_major = diameter + 2 * (1/8) * H  # slight clearance
        d_minor = diameter - 2 * (5/8) * H
        thread_depth = (5/8) * H

    # Number of full turns
    n_turns = length / pitch

    # Build the base cylinder
    if external:
        base = (
            cq.Workplane("XY")
            .circle(d_major / 2.0)
            .extrude(length)
        )
    else:
        # For internal, we return a hollow cylinder (thread bore)
        base = (
            cq.Workplane("XY")
            .circle(d_major / 2.0 + 1.0)  # outer wall
            .circle(d_minor / 2.0)          # inner bore
            .extrude(length)
        )

    # Create the helical thread profile
    # Use a triangular cross-section swept along a helix
    helix_wire = cq.Wire.makeHelix(
        pitch=pitch,
        height=length,
        radius=d_major / 2.0 if external else d_minor / 2.0 + thread_depth,
    )

    # Thread cross-section: 60-degree ISO triangle (truncated)
    crest_flat = H / 8.0
    root_flat = H / 4.0
    half_angle = math.radians(30)

    # Define the triangular thread profile points
    # Profile is in the XZ plane, positioned at the helix radius
    r = d_major / 2.0 if external else d_minor / 2.0 + thread_depth
    profile_pts = [
        (r - thread_depth, -pitch / 4.0 + root_flat / 2.0),
        (r,                -crest_flat / 2.0),
        (r,                 crest_flat / 2.0),
        (r - thread_depth,  pitch / 4.0 - root_flat / 2.0),
    ]

    # Create the profile wire
    thread_profile = (
        cq.Workplane("XZ")
        .moveTo(profile_pts[0][0], profile_pts[0][1])
        .lineTo(profile_pts[1][0], profile_pts[1][1])
        .lineTo(profile_pts[2][0], profile_pts[2][1])
        .lineTo(profile_pts[3][0], profile_pts[3][1])
        .close()
        .wire()
    )

    # Sweep the profile along the helix
    thread_solid = cq.Workplane("XY").sweep(thread_profile, helix_wire)

    return base.union(thread_solid) if external else base.cut(thread_solid)

def make_cosmetic_thread(diameter, pitch, length, external=True):
    """
    Generate a simplified cosmetic thread representation.
    Uses concentric cylinders at major and minor diameters.
    Much faster than helical sweep; sufficient for assembly visualization.
    """
    H = (math.sqrt(3) / 2.0) * pitch
    d_minor = diameter - 2 * (5/8) * H

    if external:
        # Bolt: cylinder at minor diameter with thread indicator rings
        thread = (
            cq.Workplane("XY")
            .circle(diameter / 2.0)
            .extrude(length)
        )
        # Add visual thread indicator: grooves at pitch intervals
        n_grooves = int(length / pitch)
        for i in range(n_grooves):
            z = i * pitch + pitch / 2.0
            groove = (
                cq.Workplane("XY")
                .workplane(offset=z)
                .circle(diameter / 2.0)
                .circle(d_minor / 2.0)
                .extrude(pitch * 0.1)
            )
            thread = thread.cut(groove)
        return thread
    else:
        # Nut: bore at minor diameter
        return (
            cq.Workplane("XY")
            .circle(diameter / 2.0 + 2.0)
            .circle(d_minor / 2.0)
            .extrude(length)
        )

from ocp_vscode import show

def make_bolted_joint(size, bolt_length, grip_thickness):
    """
    Assemble a complete bolted joint:
    washer + bolt through a plate, washer + nut on the other side.

    Parameters:
        size (str): Fastener size (e.g., "M8")
        bolt_length (float): Bolt length in mm
        grip_thickness (float): Total plate thickness in mm
    """
    td = THREAD_DATA[size]
    hd = HEX_BOLT_DATA[size]
    wd = WASHER_DATA[size]
    nd = HEX_NUT_DATA[size]

    # Generate components
    bolt = make_hex_bolt(size, bolt_length)
    nut = make_nut(size)
    washer_top = make_washer(size)
    washer_bottom = make_washer(size)

    # Plate with clearance hole
    clearance_dia = td["d"] + 1.0  # 1mm clearance
    plate = (
        cq.Workplane("XY")
        .box(wd["d2"] * 3, wd["d2"] * 3, grip_thickness)
        .faces(">Z")
        .workplane()
        .hole(clearance_dia)
    )

    # Position everything along the Z axis
    # Bolt head sits on top washer, on top of plate
    z_plate_top = grip_thickness / 2.0
    z_plate_bottom = -grip_thickness / 2.0

    # Top washer sits on plate surface
    washer_top = washer_top.translate((0, 0, z_plate_top))

    # Bolt head sits on top of washer
    bolt_z = z_plate_top + wd["h"]
    bolt = bolt.translate((0, 0, bolt_z))

    # Bottom washer under the plate
    washer_bottom = washer_bottom.translate(
        (0, 0, z_plate_bottom - wd["h"])
    )

    # Nut under the bottom washer
    nut_z = z_plate_bottom - wd["h"] - nd["m"]
    nut = nut.translate((0, 0, nut_z))

    return bolt, washer_top, plate, washer_bottom, nut

# Create an M8 bolted joint through a 10mm plate
components = make_bolted_joint("M8", 35, 10)
show(*components)

import os
import cadquery as cq

def generate_hardware_library(output_dir="hardware_library"):
    """
    Generate a complete ISO fastener library.

    Creates subdirectories for each fastener type and exports
    every size in both STEP and STL formats.
    """
    # Create output directory structure
    dirs = {
        "bolts": os.path.join(output_dir, "hex_bolts"),
        "screws": os.path.join(output_dir, "socket_cap_screws"),
        "nuts": os.path.join(output_dir, "hex_nuts"),
        "washers": os.path.join(output_dir, "flat_washers"),
    }
    for d in dirs.values():
        os.makedirs(d, exist_ok=True)

    sizes = ["M3", "M4", "M5", "M6", "M8", "M10", "M12", "M14", "M16", "M20"]
    bolt_lengths = [10, 16, 20, 25, 30, 40, 50]  # common lengths in mm

    file_count = 0

    # ─── Hex Bolts: each size × multiple lengths ───
    print("Generating hex bolts...")
    for size in sizes:
        for length in bolt_lengths:
            # Skip unreasonable combinations (e.g., M20x10)
            min_len = HEX_BOLT_DATA[size]["b"]  # minimum = thread length
            if length < THREAD_DATA[size]["d"] * 1.5:
                continue

            name = f"ISO4014_{size}x{length}"
            bolt = make_hex_bolt(size, length)

            cq.exporters.export(bolt, os.path.join(dirs["bolts"], f"{name}.step"))
            cq.exporters.export(bolt, os.path.join(dirs["bolts"], f"{name}.stl"))
            file_count += 2
            print(f"  {name}")

    # ─── Socket Cap Screws: each size × multiple lengths ───
    print("Generating socket cap screws...")
    for size in sizes:
        for length in bolt_lengths:
            if length < THREAD_DATA[size]["d"] * 1.5:
                continue

            name = f"ISO4762_{size}x{length}"
            screw = make_socket_cap(size, length)

            cq.exporters.export(screw, os.path.join(dirs["screws"], f"{name}.step"))
            cq.exporters.export(screw, os.path.join(dirs["screws"], f"{name}.stl"))
            file_count += 2
            print(f"  {name}")

    # ─── Hex Nuts: one per size ───
    print("Generating hex nuts...")
    for size in sizes:
        name = f"ISO4032_{size}"
        nut = make_nut(size)

        cq.exporters.export(nut, os.path.join(dirs["nuts"], f"{name}.step"))
        cq.exporters.export(nut, os.path.join(dirs["nuts"], f"{name}.stl"))
        file_count += 2
        print(f"  {name}")

    # ─── Flat Washers: one per size ───
    print("Generating flat washers...")
    for size in sizes:
        name = f"ISO7089_{size}"
        washer = make_washer(size)

        cq.exporters.export(washer, os.path.join(dirs["washers"], f"{name}.step"))
        cq.exporters.export(washer, os.path.join(dirs["washers"], f"{name}.stl"))
        file_count += 2
        print(f"  {name}")

    print(f"\nLibrary complete: {file_count} files generated in '{output_dir}/'")
    return file_count

# Run the generator
total = generate_hardware_library()