A portable, handheld two-way radio device that allows users to communicate wirelessly over short to medium distances. It operates on specific radio frequencies and features a push-to-talk button for transmitting messages, making it ideal for quick and reliable communication in outdoor, work, or emergency settings.

// Walkie Talkie
// A portable, handheld two-way radio device that allows users to communicate wirelessly over short to medium distances. It operates on specific radio frequencies and features a push-to-talk button for transmitting messages, making it ideal for quick and reliable communication in outdoor, work, or emergency settings.
// Categories: Manufacturing, Computer Hardware

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

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

// import parts and parameters
import "body.kcl" as body
import "case.kcl" as case
import "antenna.kcl" as antenna
import "talk-button.kcl" as talkButton
import "knob.kcl" as knob
import button from "button.kcl"

// Import the body
body

// Import the antenna
antenna
  |> translate(x = -width / 2 + .60, y = -0.20, z = height / 2)

// Import the case
case
  |> translate(x = 0, y = -1, z = 0)

// Import the talk button
talkButton
  |> translate(x = width / 2, y = -thickness / 2, z = .5)

// Import the frequency knob
knob
  |> translate(x = width / 2 - 0.70, y = -thickness / 2, z = height / 2)

// Import the buttons
button()
  |> translate(x = -(screenWidth / 2 + tolerance), y = -1, z = screenYPosition)
button()
  |> translate(x = -(screenWidth / 2 + tolerance), y = -1, z = screenYPosition - buttonHeight - (tolerance * 2))
button()
  |> rotate(roll = 0, pitch = 180, yaw = 0)
  |> translate(
       x = screenWidth / 2 + tolerance,
       y = -1,
       z = screenYPosition - buttonHeight,
       global = true,
     )
button()
  |> rotate(roll = 0, pitch = 180, yaw = 0)
  |> translate(
       x = screenWidth / 2 + tolerance,
       y = -1,
       z = screenYPosition - (buttonHeight * 2) - (tolerance * 2),
       global = true,
     )


// Walkie Talkie Antenna
// Antenna for the walkie talkie assembly

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

// Import parameters
import antennaLength, antennaBaseWidth, antennaBaseHeight, antennaTopWidth, antennaTopHeight from "parameters.kcl"

// Create the antenna base sketch
antennaBaseSketch = startSketchOn(XY)
  |> startProfile(at = [
       -antennaBaseWidth / 2,
       antennaBaseHeight / 2
     ])
  |> line(end = [antennaBaseWidth, 0])
  |> line(end = [0, -antennaBaseHeight])
  |> line(end = [-antennaBaseWidth, 0])
  |> close()

// Create the antenna top sketch
loftPlane = offsetPlane(XY, offset = antennaLength)
antennaTopSketch = startSketchOn(loftPlane)
  |> startProfile(at = [
       -(antennaBaseWidth - antennaTopWidth) / 2,
       (antennaBaseHeight - antennaTopHeight) / 2
     ])
  |> xLine(length = antennaTopWidth)
  |> yLine(length = -antennaTopHeight)
  |> xLine(length = -antennaTopWidth)
  |> close()

// Create the antenna using a loft
loft([antennaBaseSketch, antennaTopSketch])
  |> appearance(color = "#000000")


// Walkie Talkie Body
// The main body of the walkie talkie assembly

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

// Import parameters
import height, width, thickness, chamferLength, offset, screenWidth, screenHeight, screenYPosition, screenDepth, speakerBoxWidth, speakerBoxHeight from "parameters.kcl"

// Sketch and extrude the body of the walkie talkie
body = startSketchOn(XZ)
  |> startProfile(at = [-width / 2, height / 2])
  |> xLine(length = width, tag = $chamfer1)
  |> yLine(length = -height, tag = $chamfer2)
  |> xLine(length = -width, tag = $chamfer3)
  |> close(tag = $chamfer4)
  |> extrude(length = thickness)
  |> chamfer(
       length = chamferLength,
       tags = [
         getNextAdjacentEdge(chamfer1),
         getNextAdjacentEdge(chamfer2),
         getNextAdjacentEdge(chamfer3),
         getNextAdjacentEdge(chamfer4)
       ],
     )

// Cut out the indentation for the case
caseIndentSketch = startSketchOn(body, face = END)
  |> startProfile(at = [
       -width / 2 + offset,
       height / 2 - (chamferLength + offset / 2 * cos(45deg))
     ])
  |> angledLine(angle = 45, endAbsoluteY = height / 2 - offset)
  |> line(endAbsolute = [
       width / 2 - (chamferLength + offset / 2 * cos(45deg)),
       height / 2 - offset
     ])
  |> angledLine(angle = -45, endAbsoluteX = width / 2 - offset)
  |> line(endAbsolute = [
       width / 2 - offset,
       -(height / 2 - (chamferLength + offset / 2 * cos(45deg)))
     ])
  |> angledLine(angle = -135, endAbsoluteY = -height / 2 + offset)
  |> line(endAbsolute = [
       -(width / 2 - (chamferLength + offset / 2 * cos(45deg))),
       -height / 2 + offset
     ])
  |> angledLine(angle = -225, endAbsoluteX = -width / 2 + offset)
  |> close()
extrude002 = extrude(caseIndentSketch, length = -0.0625)

// Create the pocket for the screen
screenCutout = startSketchOn(extrude002, face = START)
  |> startProfile(at = [-screenWidth / 2, screenYPosition])
  |> xLine(length = screenWidth, tag = $seg01)
  |> yLine(length = -screenHeight)
  |> xLine(length = -segLen(seg01))
  |> line(endAbsolute = [profileStartX(%), profileStartY(%)])
  |> close()
extrude003 = extrude(screenCutout, length = screenDepth)

// Create the speaker box
speakerBox = startSketchOn(extrude002, face = START)
  |> startProfile(at = [-1.25 / 2, -.125])
  |> xLine(length = speakerBoxWidth)
  |> yLine(length = -speakerBoxHeight)
  |> xLine(length = -speakerBoxWidth)
  |> close()

extrude(speakerBox, length = -.5)
  |> appearance(color = "#277bb0")


// Walkie Talkie Button
// Button for the walkie talkie

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

// Import parameters
import buttonWidth, buttonHeight, buttonThickness from "parameters.kcl"

// Create a function for the button. We need to create a function to use multiple buttons.


export fn button() {
  // Sketch the button profile and extrude
  buttonSketch = startSketchOn(XZ)
    |> startProfile(at = [0, 0])
    |> angledLine(angle = 180, length = buttonWidth, tag = $tag1)
    |> angledLine(angle = 270, length = buttonHeight, tag = $tag2)
    |> angledLine(angle = 0, length = buttonWidth)
    |> close()
  button = extrude(buttonSketch, length = buttonThickness)
    |> chamfer(
         length = .050,
         tags = [
           getNextAdjacentEdge(tag1),
           getNextAdjacentEdge(tag2)
         ],
       )
    |> appearance(color = "#ff0000")

  return button
}


// Walkie Talkie Case
// The plastic case for the front of the walkie talkie

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

// Import parameters and Zoo logo
import width, height, chamferLength, offset, screenWidth, screenHeight, screenYPosition, screenDepth, speakerBoxWidth, speakerBoxHeight, squareHoleSideLength, caseTolerance from "parameters.kcl"
import zLogo, oLogo, oLogo2 from "zoo-logo.kcl"

// Sketch the profile of the screen
screenSketch = startSketchOn(XZ)
  |> startProfile(at = [-screenWidth / 2, screenYPosition])
  |> xLine(length = screenWidth)
  |> yLine(length = -screenHeight)
  |> xLine(length = -screenWidth)
  |> line(endAbsolute = [profileStartX(%), profileStartY(%)])
  |> close()

// Create transform functions for the speaker grid pattern
fn transformX(@i) {
  return { translate = [.125 * i, 0] }
}
fn transformY(@i) {
  return { translate = [0, -.125 * i] }
}

// Sketch the square hole grid pattern
squareHolePatternSketch = startSketchOn(XZ)
  |> startProfile(at = [-screenWidth / 2 + .100, 0])
  |> line(end = [squareHoleSideLength / 2, 0])
  |> line(end = [0, -squareHoleSideLength / 2])
  |> line(end = [-squareHoleSideLength / 2, 0])
  |> close()
  |> patternTransform2d(instances = 13, transform = transformX)
  |> patternTransform2d(instances = 11, transform = transformY)

// Sketch the outer profile of the case and extrude with holes using the previously made profiles
case = startSketchOn(XZ)
  |> startProfile(at = [
       -width / 2 + offset + caseTolerance,
       height / 2 - (chamferLength + (offset + caseTolerance) / 2 * cos(45deg))
     ])
  |> angledLine(angle = 45, endAbsoluteY = height / 2 - (offset + caseTolerance))
  |> line(endAbsolute = [
       width / 2 - (chamferLength + (offset + caseTolerance) / 2 * cos(45deg)),
       height / 2 - (offset + caseTolerance)
     ])
  |> angledLine(angle = -45, endAbsoluteX = width / 2 - (offset + caseTolerance))
  |> line(endAbsolute = [
       width / 2 - (offset + caseTolerance),
       -(height / 2 - (chamferLength + (offset + caseTolerance) / 2 * cos(45deg)))
     ])
  |> angledLine(angle = -135, endAbsoluteY = -height / 2 + offset + caseTolerance)
  |> line(endAbsolute = [
       -(width / 2 - (chamferLength + (offset + caseTolerance) / 2 * cos(45deg))),
       -height / 2 + offset + caseTolerance
     ])
  |> angledLine(angle = -225, endAbsoluteX = -width / 2 + offset + caseTolerance)
  |> close()
  |> subtract2d(tool = screenSketch)
  |> subtract2d(tool = squareHolePatternSketch)

  // Create the Zoo logo
  |> subtract2d(tool = zLogo(surface = startSketchOn(XZ), origin = [-.30, -1.825], scale = .20))
  |> subtract2d(tool = oLogo(surface = startSketchOn(XZ), origin = [-.075, -1.825], scale = .20))
  |> subtract2d(tool = oLogo2(surface = startSketchOn(XZ), origin = [-.075, -1.825], scale = .20))
  |> subtract2d(tool = oLogo(surface = startSketchOn(XZ), origin = [.175, -1.825], scale = .20))
  |> subtract2d(tool = oLogo2(surface = startSketchOn(XZ), origin = [.175, -1.825], scale = .20))
extrude(case, length = -0.0625)
  |> appearance(color = '#D0FF01', metalness = 0, roughness = 50)


// Walkie Talkie Frequency Knob
// The frequency knob for the walkie talkie assembly

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

// Import parameters
import width, thickness, height, knobDiameter, knobHeight, knobFilletRadius from "parameters.kcl"

// Create the knob sketch and revolve
startSketchOn(XY)
  |> circle(center = [0, 0], radius = knobDiameter / 2, tag = $knobBend)
  |> extrude(length = knobHeight)
  |> fillet(radius = knobFilletRadius, tags = [getOppositeEdge(knobBend)])
  |> appearance(color = "#afbf36")


// Global parameters for the walkie talkie

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

// body
export height = 4
export width = 2.5
export thickness = 1
export chamferLength = .325
export offset = .125
export screenWidth = 1.75
export screenHeight = 1
export screenYPosition = height / 2 - 0.75
export screenDepth = -.0625
export speakerBoxWidth = 1.25
export speakerBoxHeight = 1.25

// antenna
export antennaBaseWidth = .5
export antennaBaseHeight = .25
export antennaTopWidth = antennaBaseWidth * .5
export antennaTopHeight = antennaBaseHeight * .5
export antennaLength = 2

// button
export buttonWidth = .15
export tolerance = 0.020
export buttonHeight = screenHeight / 2 - tolerance
export buttonThickness = .040

// case
export squareHoleSideLength = 0.0625
export caseTolerance = 0.010

// knob
export knobDiameter = .5
export knobHeight = .25
export knobFilletRadius = 0.050

// talk-button
export talkButtonSideLength = 0.5
export talkButtonHeight = 0.050


// Walkie talkie talk button

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

// Import parameters
import width, thickness, talkButtonSideLength, talkButtonHeight from "parameters.kcl"

// Create the talk button sketch
talkButtonSketch = startSketchOn(YZ)
  |> startProfile(at = [
       -talkButtonSideLength / 2,
       talkButtonSideLength / 2
     ])
  |> xLine(length = talkButtonSideLength, tag = $tag1)
  |> yLine(length = -talkButtonSideLength, tag = $tag2)
  |> xLine(length = -talkButtonSideLength, tag = $tag3)
  |> close(tag = $tag4)

// create the talk button and apply fillets
extrude(talkButtonSketch, length = talkButtonHeight)
  |> fillet(
       radius = 0.050,
       tags = [
         getNextAdjacentEdge(tag1),
         getNextAdjacentEdge(tag2),
         getNextAdjacentEdge(tag3),
         getNextAdjacentEdge(tag4)
       ],
     )
  |> appearance(color = '#D0FF01', metalness = 90, roughness = 90)


// Zoo logo

// define a function to draw the ZOO "Z"
export fn zLogo(surface, origin, scale) {
  zSketch = surface
    |> startProfile(at = [
         0 + origin[0],
         0.15 * scale + origin[1]
       ])
    |> yLine(length = -0.15 * scale)
    |> xLine(length = 0.15 * scale)
    |> angledLine(angle = 47.15, endAbsoluteX = 0.3 * scale + origin[0], tag = $seg1)
    |> yLine(endAbsolute = 0 + origin[1], tag = $seg3)
    |> xLine(length = 0.63 * scale)
    |> yLine(length = 0.225 * scale)
    |> xLine(length = -0.57 * scale)
    |> angledLine(angle = 47.15, endAbsoluteX = 0.93 * scale + origin[0])
    |> yLine(length = 0.15 * scale)
    |> xLine(length = -0.15 * scale)
    |> angledLine(angle = 47.15, length = -segLen(seg1), tag = $seg2)
    |> yLine(length = segLen(seg3))
    |> xLine(endAbsolute = 0 + origin[0])
    |> yLine(length = -0.225 * scale)
    |> angledLineThatIntersects(angle = 0, intersectTag = seg2, offset = 0)
    |> close()
  return zSketch
}

// define a function to draw the ZOO "O"
export fn oLogo(surface, origin, scale) {
  oSketch001 = surface
    |> startProfile(at = [
         .788 * scale + origin[0],
         .921 * scale + origin[1]
       ])
    |> arc(angleStart = 47.15 + 6, angleEnd = 47.15 - 6 + 180, radius = .525 * scale)
    |> angledLine(angle = 47.15, length = .24 * scale)
    |> arc(angleStart = 47.15 - 11 + 180, angleEnd = 47.15 + 11, radius = .288 * scale)
    |> close()
  return oSketch001
}

export fn oLogo2(surface, origin, scale) {
  oSketch002 = surface
    |> startProfile(at = [
         .16 * scale + origin[0],
         .079 * scale + origin[1]
       ])
    |> arc(angleStart = 47.15 + 6 - 180, angleEnd = 47.15 - 6, radius = .525 * scale)
    |> angledLine(angle = 47.15, length = -.24 * scale)
    |> arc(angleStart = 47.15 - 11, angleEnd = 47.15 + 11 - 180, radius = .288 * scale)
    |> close()
  return oSketch002
}


walkie-talkie

KCL