A car wheel assembly with a rotor, tire, and lug nuts.

// Car Wheel Assembly
// A car wheel assembly with a rotor, tire, and lug nuts.
// Categories: Automotive

// Define units
@settings(defaultLengthUnit = in)

// Import parameters
import * from "parameters.kcl"

// Import parts
import "brake-caliper.kcl" as brakeCaliper
import "brake-rotor.kcl" as brakeRotor
import "car-tire.kcl" as carTire
import "car-wheel.kcl" as carWheel
import "lug-nut.kcl" as lugNut
lugNut
  |> patternCircular3d(instances = lugCount, axis = Y, center = [0, 0, 0])


// Brake Caliper
// Brake calipers are used to squeeze the brake pads against the rotor, causing larger and larger amounts of friction depending on how hard the brakes are pressed.

// Set units
@settings(defaultLengthUnit = in, kclVersion = 1.0)

// Import parameters
import * from "parameters.kcl"

// Define a start plane though the center of the brake rotor discs
caliperPlane = offsetPlane(XZ, offset = tBell - hBellAboveDiscFace - tDiscHalf - (tVent / 2))

// Create a cutout of the brake rotor shape
sketch003 = startSketchOn(caliperPlane)
  |> circle(diameter = rotorDiameter + 0.2)
  |> extrude(length = 2 * tDiscHalf + tVent + 0.2, symmetric = true)

// Sketch a brake caliper profile using the rotor diameter as a guide
baseSketch = startSketchOn(caliperPlane)
  |> startProfile(at = [-rotorDiameter / 2.8, 0])
  |> yLine(length = rotorDiameter / 20)
  |> angledLine(angle = 135deg, length = rotorDiameter / 40)
  |> yLine(length = rotorDiameter / 40, tag = $seg02)
  |> arc(angleStart = -90, angleEnd = 90, radius = rotorDiameter / 60)
  |> angledLine(angle = 60deg, length = rotorDiameter / 15)
  |> yLine(length = rotorDiameter / 9)
  |> angledLine(angle = 120deg, length = rotorDiameter / 14)
  |> tangentialArc(angle = 105deg, radius = rotorDiameter / 60)
  |> tangentialArc(angle = 25deg, diameter = rotorDiameter)
  |> yLine(length = -rotorDiameter / 40)
  |> tangentialArc(angle = -90deg, radius = rotorDiameter / 60)
  |> tangentialArc(angle = 180deg, radius = rotorDiameter / 60)
  |> tangentialArc(angle = -120deg, radius = rotorDiameter / 60)
  |> angledLine(angle = -127deg, length = rotorDiameter / 30)
  |> yLine(endAbsolute = 0)
  |> mirror2d(axis = X)
  |> close()
  |> extrude(length = caliperThickness * 5 / 6, symmetric = true)

  // Cut the rotor opening from the caliper
  |> subtract(tools = sketch003)

  // Add a bright appearance to the caliper
  |> appearance(color = "#ce0909")

// Draw a profile for the outer piece on the brake caliper
outerSketch = startSketchOn(baseSketch, face = END)
  |> startProfile(at = [-rotorDiameter / 2.8, 0])
  |> yLine(length = rotorDiameter / 20)
  |> angledLine(angle = 135deg, length = rotorDiameter / 40)
  |> yLine(length = rotorDiameter / 40)
  |> arc(angleStart = -90, angleEnd = 90, radius = rotorDiameter / 60)
  |> angledLine(angle = 60deg, length = rotorDiameter / 25)
  |> tangentialArc(angle = 60deg, radius = rotorDiameter / 60)
  |> tangentialArc(angle = -20deg, radius = rotorDiameter / 20, tag = $seg01)
  |> angledLine(angle = tangentToEnd(seg01), length = rotorDiameter / 15)
  |> xLine(length = -rotorDiameter / 20)
  |> angledLine(angle = -120deg, length = rotorDiameter / 20)
  |> angledLine(angle = -100deg, length = rotorDiameter / 10)
  |> tangentialArc(angle = -45deg, radius = rotorDiameter / 60)
  |> tangentialArc(angle = 90deg, radius = rotorDiameter / 60)
  |> tangentialArc(angle = -35deg, radius = rotorDiameter / 60)
  |> yLine(endAbsolute = 0)
  |> mirror2d(axis = X)
  |> close()
  |> extrude(length = caliperThickness / 6)

// Create two nubs on the caliper outer face
nubSketch = startSketchOn(outerSketch, face = END)
nub01 = circle(
  nubSketch,
  center = [
    segEndX(seg02),
    segEndY(seg02) + rotorDiameter / 60
  ],
  radius = rotorDiameter / 100,
)
nub02 = circle(
  nubSketch,
  center = [
    segEndX(seg02),
    -segEndY(seg02) - (rotorDiameter / 60)
  ],
  radius = rotorDiameter / 100,
)
nubs = extrude([nub01, nub02], length = -0.05)

// Draw a ZOO logo on the caliper outer
// Define a function to draw the ZOO "Z"
fn zLogo(surface, origin, fontSize, depth) {
  zSketch = surface
    |> startProfile(at = [0 + origin[0], 0.15 + origin[1]])
    |> yLine(length = -0.15)
    |> xLine(length = 0.15)
    |> angledLine(angle = 47.15, endAbsoluteX = 0.3 + origin[0], tag = $seg1)
    |> yLine(endAbsolute = 0 + origin[1], tag = $seg3)
    |> xLine(length = 0.63)
    |> yLine(length = 0.225)
    |> xLine(length = -0.57)
    |> angledLine(angle = 47.15, endAbsoluteX = 0.93 + origin[0])
    |> yLine(length = 0.15)
    |> xLine(length = -0.15)
    |> angledLine(angle = 47.15, length = -segLen(seg1), tag = $seg2)
    |> yLine(length = segLen(seg3))
    |> xLine(endAbsolute = 0 + origin[0])
    |> yLine(length = -0.225)
    |> angledLineThatIntersects(angle = 0, intersectTag = seg2, offset = 0)
    |> close()
    |> rotate(pitch = -90)
    |> scale(x = fontSize / 72, z = fontSize / 72)
    |> extrude(length = depth)

  return zSketch
}

// Define a function to draw the ZOO "O"
fn oLogo(surface, origin, fontSize, depth) {
  otagSketch = surface
    |> startProfile(at = [.788 + origin[0], .921 + origin[1]])
    |> arc(angleStart = 47.15 + 6, angleEnd = 47.15 - 6 + 180, radius = .525)
    |> angledLine(angle = 47.15, length = .24)
    |> arc(angleStart = 47.15 - 11 + 180, angleEnd = 47.15 + 11, radius = .288)
    |> close(%)
    |> rotate(pitch = -90)
    |> scale(x = fontSize / 72, z = fontSize / 72)
    |> extrude(length = depth)

  oouterSketch = surface
    |> startProfile(at = [.16 + origin[0], .079 + origin[1]])
    |> arc(angleStart = 47.15 + 6 - 180, angleEnd = 47.15 - 6, radius = .525)
    |> angledLine(angle = 47.15, length = -.24)
    |> arc(angleStart = 47.15 - 11, angleEnd = 47.15 + 11 - 180, radius = .288)
    |> close(%)
    |> rotate(pitch = -90)
    |> scale(x = fontSize / 72, z = fontSize / 72)
    |> extrude(length = depth)
  return [otagSketch, oouterSketch]
}

// Create each letter using the letter functions
z = zLogo(
  surface =   startSketchOn(outerSketch, face = END),
  origin = [-1.57, rotorDiameter * 0.8],
  fontSize = 36,
  depth = -0.025,
)

o = oLogo(
  surface =   startSketchOn(outerSketch, face = END),
  origin = [-0.545, rotorDiameter * 0.8],
  fontSize = 36,
  depth = -0.025,
)
oo = oLogo(
  surface =   startSketchOn(outerSketch, face = END),
  origin = [0.585, rotorDiameter * 0.8],
  fontSize = 36,
  depth = -0.025,
)


// Brake Rotor
// A 320mm vented brake disc (rotor), with straight vanes, 30mm thick. The disc bell should accommodate 5 M12 wheel studs on a 114.3mm pitch circle diameter.

// Define units
@settings(defaultLengthUnit = in)

// Import parameters
import * from "parameters.kcl"

// Sketch a profile for the center bell, then rotate
sketchDiscBell = startSketchOn(-XY)
  |> startProfile(at = [rotorBore / 2, 0])
  |> yLine(length = -tBell)
  |> xLine(endAbsolute = (lugSpacing + rotorBore) / 2)
  |> angledLine(angle = rDraftAngle, lengthY = hBellAboveDiscFace, tag = $seg08)
  |> tangentialArc(angle = -90 - rDraftAngle, diameter = wUndercut, tag = $seg06)
  |> angledLine(angle = tangentToEnd(seg06) + turns::HALF_TURN, length = tDiscHalf, tag = $seg07)
  |> xLine(length = -1 * (tBell + wUndercut), tag = $seg04)
  |> angledLine(angle = segAng(seg08) + 180deg, endAbsoluteY = profileStartY())
  |> line(endAbsolute = [profileStartX(%), profileStartY(%)], tag = $seg09)
  |> close()
  |> revolve(axis = Y)

// Drill lug holes
sketchLugs = startSketchOn(sketchDiscBell, face = seg09)
  |> circle(center = [-lugSpacing / 2, 0], diameter = lugThreadDiameter)
  |> patternCircular2d(instances = lugCount, center = [0, 0], arcDegrees = 360deg)
  |> extrude(length = -tBell * 2)

// Create vents
sketchVent = startSketchOn(sketchDiscBell, face = seg04)
  |> startProfile(at = [rVentFillet, rotorDiameter / 2])
  |> xLine(length = wVent - (2 * rVentFillet))
  |> tangentialArc(angle = -90deg, radius = rVentFillet)
  |> yLine(length = -hFrictionSurface + 2 * rVentFillet, tag = $seg10)
  |> tangentialArc(angle = -90deg, radius = rVentFillet)
  |> xLine(endAbsolute = profileStartX())
  |> tangentialArc(angle = -90deg, radius = rVentFillet)
  |> yLine(length = segLen(seg10))
  |> tangentialArc(endAbsolute = [profileStartX(%), profileStartY(%)])
  |> close()
ventPad = extrude(sketchVent, length = tVent, method = NEW)

// Pattern vents around the perimeter of the rotor
ventSet = patternCircular3d(
  ventPad,
  instances = nVentBosses,
  axis = Y,
  center = [0, 0, 0],
)

// Sketch a drilled hole pattern on the rotor discs
fn drillHole(@t) {
  rInner = rotorDiameter / 2 - hFrictionSurface
  rOuter = rotorDiameter / 2

  aStart = aBase
  aEnd = aBase - aSweep

  rCurrent = rInner + t * (rOuter - rInner)
  aCurrent = aStart + t * (aEnd - aStart)

  xCenter = rCurrent * cos(aCurrent)
  yCenter = rCurrent * sin(aCurrent)

  return { x = xCenter, y = yCenter }
}

// Use a function to create each rotor disc
fn createDiscHalf(@face) {
  sketchFace = startSketchOn(ventPad, face)
    |> circle(radius = rotorDiameter / 2)
    |> subtract2d(tool = circle(radius = rotorDiameter / 2 - hFrictionSurface))

  // Create three circles at t = 0.2, 0.5, and 0.8 directly on this sketch
  c1 = drillHole(0.2)
  c2 = drillHole(0.5)
  c3 = drillHole(0.8)

  hole1 = circle(sketchFace, center = [c1.x, c1.y], radius = dDrillDia / 2)
  hole2 = circle(sketchFace, center = [c2.x, c2.y], radius = dDrillDia / 2)
  hole3 = circle(sketchFace, center = [c3.x, c3.y], radius = dDrillDia / 2)

  holes = patternCircular2d([hole1, hole2, hole3], instances = nArcs, center = [0, 0])

  profileDrilled = subtract2d(sketchFace, tool = holes)

  discHalf = extrude(profileDrilled, length = tDiscHalf, method = NEW)
  return discHalf
}

// Create inboard half
discInboard = createDiscHalf(START)

// Create outboard half
discOutboard = patternLinear3d(
  discInboard,
  axis = [0, 1, 0],
  distance = tVent + tDiscHalf,
  instances = 2,
)

rotor = appearance(
  [sketchDiscBell, ventSet, discOutboard],
  color = "#f0d77a",
  metalness = 70,
  roughness = 30,
)


// Tire
// A tire is a critical component of a vehicle that provides the necessary traction and grip between the car and the road. It supports the vehicle's weight and absorbs shocks from road irregularities.

// Set units
@settings(defaultLengthUnit = in, kclVersion = 1.0)

// Import parameters
import * from "parameters.kcl"

// Create the sketch of the tire
tireSketch = startSketchOn(XY)
  |> startProfile(at = [overallDiameter / 2, 0])
  |> yLine(length = tireWidth / 4)
  |> arc(angleStart = 270, angleEnd = 90, radius = treadDepth)
  |> yLine(endAbsolute = tireWidth / 2 - (tireWidth / 10))
  |> tangentialArc(angle = 85deg, radius = tireWidth / 10)
  |> tangentialArc(endAbsolute = [rimDiameter / 2, wheelWidth / 2], tag = $seg02)
  |> yLine(length = -sidewallThickness)
  |> angledLine(angle = tangentToEnd(seg02), length = -0.1)
  |> tangentialArc(endAbsolute = [
       overallDiameter / 2 - 1,
       tireWidth / 2.4
     ])
  |> yLine(endAbsolute = 0)
  |> mirror2d(axis = X)
  |> close()

// Revolve the sketch to create the tire
carTire = revolve(tireSketch, axis = Y)
  |> appearance(color = "#0a0a0a", roughness = 20)
  |> translate(y = -tBell + offset)


// Car Wheel
// A sports car wheel with a circular lug pattern and spokes.

// Define units
@settings(defaultLengthUnit = in)

// Import parameters
import * from "parameters.kcl"

// Create the cutout for each mounting lug
lugMounts = startSketchOn(XY)
  |> startProfile(at = [lugSpacing / 2, 0])
  |> xLine(length = lugThreadDiameter / 2)
  |> yLine(length = -tBell - 0.85)
  |> xLine(endAbsolute = profileStartX() + lugDiameter / 2)
  |> yLine(length = -lugLength * 2)
  |> xLine(endAbsolute = profileStartX())
  |> yLine(endAbsolute = profileStartY(), tag = $seg01)
  |> close()
  |> revolve(axis = seg01)

// Draw a profile for the center of the wheel, and revolve
wheelCenter = startSketchOn(XY)
  |> startProfile(at = [rotorBore / 2, -tBell])
  |> yLine(length = -0.75)
  |> xLine(endAbsolute = 0)
  |> yLine(length = -0.5)
  |> arc(angleStart = 270deg, angleEnd = 290deg, radius = lugSpacing / 1.15)
  |> xLine(endAbsolute = lugSpacing / 2.15)
  |> tangentialArc(angle = -50deg, radius = lugSpacing / 7)
  |> tangentialArc(angle = 30deg, radius = lugSpacing / 7)
  |> angledLine(angle = 90deg - (90 / spokeCount), endAbsoluteY = profileStartY(), tag = $seg02)
  |> xLine(endAbsolute = profileStartX())
  |> close()
  |> revolve(axis = Y)
  |> subtract(tools =   lugMounts
    |> patternCircular3d(instances = lugCount, axis = [0, -1, 0], center = [0, 0, 0]))

// Define and revolve the wheel exterior. Adjust position based on wheel parameters and offset
rim = startSketchOn(XY)
  |> startProfile(at = [
       rimDiameter / 2,
       segEndY(seg02) - (wheelWidth / 2) + offset
     ])
  |> yLine(length = wheelWidth * 0.15, tag = $seg04)
  |> angledLine(angle = 135deg, lengthY = wheelWidth * 0.025)
  |> yLine(length = wheelWidth * 0.25)
  |> angledLine(angle = 45deg, lengthY = wheelWidth * 0.025)
  |> yLine(length = wheelWidth * 0.55, tag = $seg03)
  |> line(end = [wheelWidth * 0.05, wheelWidth * .01])
  |> yLine(length = wheelWidth * 0.025)
  |> xLine(length = -wheelWidth * 0.02)
  |> yLine(length = -wheelWidth * 0.01)
  |> line(end = [-wheelWidth * 0.05, -wheelWidth * 0.01])
  |> yLine(length = -segLen(seg03))
  |> angledLine(angle = 45deg, lengthY = -wheelWidth * 0.025)
  |> yLine(length = -wheelWidth * 0.1)
  |> angledLine(angle = 200deg, lengthX = wheelWidth * 0.07, tag = $seg08)
  |> yLine(length = -.2, tag = $seg06)
  |> angledLine(angle = -45deg, lengthX = wheelWidth * 0.07, tag = $seg05)
  |> yLine(length = -wheelWidth * 0.065)
  |> angledLine(angle = 135deg, lengthY = -wheelWidth * 0.025)
  |> angledLine(angle = -90deg, length = segLen(seg04))
  |> line(end = [wheelWidth * 0.05, -wheelWidth * 0.01])
  |> yLine(length = -wheelWidth * 0.01)
  |> xLine(length = wheelWidth * 0.02)
  |> yLine(length = wheelWidth * 0.025)
  |> line(endAbsolute = [profileStartX(), profileStartY()])
  |> close()
  |> revolve(axis = Y)

// Profile the side view of a wheel spoke
spokeSide = startSketchOn(XY)
  |> startProfile(at = segStart(seg02))
  |> line(endAbsolute = segEnd(seg02))
  |> angledLine(angle = -32deg, length = 0.1)
  |> tangentialArc(endAbsolute = segStart(seg06), tag = $seg09)
  |> line(endAbsolute = segEnd(seg06))
  |> line(endAbsolute = segEnd(seg05))
  |> angledLine(angle = tangentToEnd(seg09) + 5, length = -0.01)
  |> tangentialArc(endAbsolute = [profileStartX(), profileStartY()])
  |> close()

// Profile the face view of a wheel spoke
spokeFace = startSketchOn(XZ)
  |> startProfile(at = [-lugSpacing / 1.25, 0])
  |> arc(
       angleStart = 0,
       angleEnd = 90 - (170 / spokeCount),
       radius = lugSpacing / spokeCount,
       tag = $seg07,
     )
  |> angledLine(angle = tangentToEnd(seg07), length = rimDiameter / 2)
  |> tangentialArc(angle = -180deg, diameter = 0.25)
  |> line(endAbsolute = polar(angle = 180 - (140 / spokeCount), length = segEndX(seg02)))
  |> tangentialArc(endAbsolute = polar(angle = 180 - (180 / spokeCount), length = segStartX(seg02) + 0.01))
  |> arc(interiorAbsolute = polar(angle = 180 - (180 / spokeCount / 2), length = segStartX(seg02)), endAbsolute = [-segStartX(seg02), 0])
  // Mirror the spoke on it's center axis
  |> mirror2d(axis = X)
  |> close()

// Create a spoke by intersecting the side and face profiles, then pattern around the center of the wheel
spokes = intersect([
       spokeFace
  |> extrude(length = wheelWidth * 2),
       spokeSide
  |> rotate(pitch = 90)
  |> revolve(axis = Y)
     ])
  |> patternCircular3d(instances = spokeCount, axis = Y, center = [0, 0, 0])

wheel = appearance(
  [wheelCenter, spokes, rim],
  color = "#ededed",
  metalness = 70,
  roughness = 30,
)


// Lug Nut
// lug Nuts are essential components used to create secure connections, whether for electrical purposes, like terminating wires or grounding, or for mechanical purposes, such as providing mounting points or reinforcing structural joints.

// Set units
@settings(defaultLengthUnit = in, kclVersion = 1.0)

// Import parameters
import * from "parameters.kcl"

customPlane = {
  origin = {
    x = lugSpacing / 2,
    y = (-tBell - 0.85) * 25.4,
    z = 0
  },
  xAxis = { x = 1, y = 0, z = 0 },
  yAxis = { x = 0, y = -1, z = 0 }
}

lugNut = startSketchOn(customPlane)
  |> startProfile(at = [0 + lugDiameter / 2, 0])
  |> yLine(length = lugLength)
  |> tangentialArc(angle = 90deg, radius = 3mm)
  |> xLine(endAbsolute = 0, tag = $c1)
  |> yLine(endAbsolute = lugLength * 0.6)
  |> xLine(length = segLen(c1))
  |> line(endAbsolute = [profileStartX(%), profileStartY(%)])
  |> close()
  |> revolve(axis = Y)
  |> appearance(color = "#ededed", metalness = 70, roughness = 30)


// Car wheel assembly parameters

// Set units
@settings(defaultLengthUnit = in, kclVersion = 1.0)

// Lugs
export lugCount = 5
export lugSpacing = 114.3mm
export lugDiameter = 24mm
export lugThreadDiameter = lugDiameter / 1.75
export lugLength = 5 / 8

// Car wheel
export spokeCount = 5
export offset = -10mm
export wheelWidth = 9.5
export rimDiameter = 18

// Brake caliper
export caliperThickness = 2.5

// Brake rotor
export rotorDiameter = 12
export rotorBore = 3
export hFrictionSurface = 2.36
export tDiscHalf = 3 / 8
export tVent = 3 / 8
export wVent = 1 / 4
export rVentFillet = 1 / 10
export nVentBosses = 36
export dDrillDia = 1 / 4
export aBase = 90deg
export aSweep = 30deg
export nArcs = 12
export tBell = 0.2
export hBellAboveDiscFace = 1.5
export wUndercut = 0.2
export rDraftAngle = 83deg

// Car tire
export tireWidth = 255mm
export aspectRatio = 30
export overallDiameter = rimDiameter + tireWidth * aspectRatio * 0.02
export sidewallThickness = 6mm
export treadDepth = 3mm


Geometry Engine

car-wheel-assembly

KCL