Week 12 — Mechanical Design

Overview

For Week 12, I explored mechanical design through a kinetic mechanical clock prototype. The project was inspired by kinetic mechanical sculptures, especially circular mechanisms that create movement through repeated linkage parts.

The final prototype combines several fabrication methods. The main moving linkage parts were made from 3 mm laser-cut wood board. The motor holder and fixing parts were designed in Fusion 360 and made with 3D printing. The clock structure was supported by aluminum extrusion, and a stepper motor was used as the actuator.

The purpose of this project was not only to make a clock, but also to make time visible as a mechanical movement. The clock face changes its form through the linkage mechanism, turning time into a kinetic visual experience.

Assignment

Group Assignment

The group assignment was to design a machine that includes mechanism, actuation, automation, function, and user interface. We also needed to build the mechanical parts, operate them manually, and document the group project and individual contribution.

Individual Assignment

My individual work focused on designing and fabricating a kinetic linkage clock prototype. I studied the reference mechanism, tested the linkage movement, fabricated the mechanical parts, designed the motor holder and center hand, assembled the structure, and tested the stepper motor control system.

Project Concept: Kinetic Mechanical Sculpture Style

At the beginning of this project, I wanted to make a clock with a strong mechanical and sculptural feeling. I looked at kinetic mechanical sculpture references and found that repeated radial parts can create a rich motion effect when they are driven by a single rotating center.

I defined the project as a kinetic mechanical clock prototype. The clock uses repeated linkage parts around the center shaft. When the center part rotates, the surrounding parts move together and create an opening and closing movement.

This project was also inspired by the kinetic clock works from Animaro Design . I used this reference to understand how a linkage mechanism can be used to visualize time, then made my own prototype with the fabrication methods available in the Fab Lab.

System Design

The system can be divided into four main parts: the linkage clock mechanism, the support structure, the actuator, and the control system. The clock face is driven from the center. The stepper motor rotates the center shaft, and the surrounding linkage parts transform this rotation into a changing circular form.

Stepper motor rotates
        ↓
Center shaft turns
        ↓
Center hand drives the linkage mechanism
        ↓
Repeated wooden linkage parts move together
        ↓
Clock face opens and closes
        ↓
Mechanical movement visualizes the passing of time

Step 1: Reference and Mechanism Study

First, I studied the working principle of a kinetic linkage clock. The most important idea is that one central rotating part can control many repeated linkage modules around the clock face. When the center part rotates, the whole linkage system changes between a closed shape and an open circular shape.

I analyzed the visual style and the movement logic. I wanted the final object to look like a mechanical sculpture, so I kept the repeated radial pattern and visible mechanical joints.

At this stage, I mainly used the reference images and my own manual tests to understand the mechanism. I did not make a separate motion analysis drawing, so I focused the documentation on the physical prototype tests instead.

Step 2: 3D Printed Linkage Test

Before making the wooden version, I first tested the linkage mechanism with 3D printed parts. This stage helped me understand the basic movement, the joint positions, and how the repeated parts form a circular clock face.

This first test was mainly a manual mechanical test. I did not use a motor at this stage. I moved the parts by hand to observe how the mechanism opened and closed.

During this test, I found that the 3D printed joints were relatively stiff. Because the holes and printed surfaces had friction, the movement required more force than expected. This showed me that the final version needed better joint clearance and smoother material behavior.

Step 3: CAD Design and Fabrication Planning

After the first test, I continued to model and adjust the parts in Fusion 360. I separated the project into different mechanical parts: linkage parts, center hand, motor holder, and frame connection parts.

I decided to use laser cutting for the repeated linkage parts because they are flat, repeated, and need to be produced many times. Laser cutting is faster and more suitable for this type of part compared with printing every linkage piece.

Step 4: Laser Cutting the Wooden Linkage Parts

After the 3D printed test, I changed the main linkage parts to 3 mm laser-cut wood board. The wooden parts were lighter and faster to fabricate, which made them more suitable for a clock face with many repeated linkage components.

The holes on the parts were designed for M3 screws, so each part could rotate around its joint point. The laser-cut parts helped reduce weight, but the mechanism still needed careful adjustment because it contained many pivot joints.

Step 5: Designing the Motor Holder and Center Hand

The actuator of the clock was a 42BYGH series stepper motor. This motor is similar to a NEMA 17 stepper motor. It has a square front face, four M3 mounting holes, and a 5 mm output shaft. I used these dimensions as the basis for designing the motor fixing structure.

I used the motor dimension drawing to design the motor holder and the center hand in Fusion 360. The motor holder was used to position and fix the stepper motor, while the center hand was designed to transfer the motor rotation to the linkage clock mechanism.

Since the clock face was driven from the center, the relationship between the motor shaft, the center hand, and the linkage parts was very important. If the center hand was not aligned with the motor shaft, the linkage structure would create extra friction during movement.

Step 6: Frame and Support Structure

The clock needed a stable support structure because the linkage face was relatively large. I used aluminum extrusion to build the support frame. The vertical extrusion supports the clock face, and the base keeps the structure standing.

I did not record a separate frame assembly image, but the aluminum extrusion frame can be seen in the final prototype. It made the prototype easier to adjust during both the mechanical test and the motor test.

Step 7: Electronics and Wiring

I used a XIAO ESP32S3 to control a TMC2209 stepper motor driver. The TMC2209 receives DIR, STEP, and ENABLE signals from the microcontroller and drives the stepper motor with an external 12V power supply.

The motor power and the logic power are separated. The 12V power supply is connected to the motor power input of the TMC2209, while the XIAO provides logic control signals. The ground of the XIAO and the ground of the TMC2209 must be connected together.

Step 8: Stepper Motor Control

After finishing the basic wiring, I tested the stepper motor control system with the XIAO ESP32S3 and the TMC2209 driver. Before connecting the motor to the full clock mechanism, I first needed to confirm that the motor could rotate correctly in both directions.

In the physical motor test video, I only tested the basic clockwise and counterclockwise rotation. This helped me check the wiring, the DIR pin, the STEP pin, the ENABLE pin, and the motor coil connection before using the motor to drive the clock structure.

After the direction test worked, I wrote a smoother clock demo program. This code was designed as a 60-second demo mode. The motor moves once every second and completes one full revolution in 60 seconds, similar to a second-hand movement. This program was prepared for driving the kinetic clock mechanism more smoothly.

I used 60 ticks for one revolution. The motor moves to a new target position every second. To make each movement smoother, I used an ease-in-out function based on a cosine curve. This makes each tick start slowly, accelerate in the middle, and slow down again before stopping.

60 ticks per revolution
        ↓
1 tick every second
        ↓
Stepper motor moves to the next target position
        ↓
Ease-in-out function smooths the movement
        ↓
The clock completes one full revolution in 60 seconds

#ifndef D0
#define D0 2
#endif
#ifndef D1
#define D1 3
#endif
#ifndef D2
#define D2 4
#endif

#include <math.h>

const uint8_t PIN_DIR = D0;
const uint8_t PIN_STEP = D1;
const uint8_t PIN_ENABLE = D2;

const bool ENABLE_ACTIVE_LOW = true;
const bool DIR_INVERT = true;

const int FULL_STEPS_PER_REV = 200;
const int MICROSTEPS = 8;
const long STEPS_PER_REV = (long)FULL_STEPS_PER_REV * MICROSTEPS;

// Clock movement parameters
const int TICKS_PER_REV = 60;        // second-hand effect: 60 ticks per revolution
const int MOVE_TIME_MS = 350;        // movement duration for each tick
const int TICK_INTERVAL_MS = 1000;   // move once every second

const uint16_t STEP_PULSE_US = 4;

long currentPosition = 0;
long tickCount = 0;
unsigned long nextTickTime = 0;

void setEnable(bool enable) {
  if (ENABLE_ACTIVE_LOW) {
    digitalWrite(PIN_ENABLE, enable ? LOW : HIGH);
  } else {
    digitalWrite(PIN_ENABLE, enable ? HIGH : LOW);
  }
}

void setDirection(int direction) {
  bool level = direction > 0;
  if (DIR_INVERT) level = !level;
  digitalWrite(PIN_DIR, level ? HIGH : LOW);
}

void doStep() {
  digitalWrite(PIN_STEP, HIGH);
  delayMicroseconds(STEP_PULSE_US);
  digitalWrite(PIN_STEP, LOW);
  delayMicroseconds(STEP_PULSE_US);
}

// Ease-in-out movement function
float easeInOut(float t) {
  return 0.5f - 0.5f * cosf(PI * t);
}

// Smoothly move to a target step position
void smoothMoveTo(long targetPosition, int durationMs) {
  long startPosition = currentPosition;
  long distance = targetPosition - startPosition;

  if (distance == 0) return;

  int direction = distance > 0 ? 1 : -1;
  setDirection(direction);

  unsigned long startTime = millis();

  while (true) {
    unsigned long now = millis();
    float t = (float)(now - startTime) / durationMs;

    if (t >= 1.0f) break;

    float eased = easeInOut(t);
    long desiredPosition = startPosition + round(distance * eased);

    while (currentPosition != desiredPosition) {
      doStep();
      currentPosition += direction;
    }
  }

  // Final correction to make sure every tick position is accurate
  while (currentPosition != targetPosition) {
    doStep();
    currentPosition += direction;
  }
}

void setup() {
  pinMode(PIN_DIR, OUTPUT);
  pinMode(PIN_STEP, OUTPUT);
  pinMode(PIN_ENABLE, OUTPUT);

  digitalWrite(PIN_STEP, LOW);
  setEnable(true);

  Serial.begin(115200);
  delay(300);

  Serial.println("Smooth clock stepper started.");
  Serial.println("1 tick per second.");

  nextTickTime = millis() + TICK_INTERVAL_MS;
}

void loop() {
  if (millis() >= nextTickTime) {
    tickCount++;

    // Use accumulated target position to avoid rounding error from 1600 / 60
    long targetPosition = round((float)tickCount * STEPS_PER_REV / TICKS_PER_REV);

    smoothMoveTo(targetPosition, MOVE_TIME_MS);

    Serial.print("Tick: ");
    Serial.print(tickCount);
    Serial.print("  Position: ");
    Serial.println(currentPosition);

    nextTickTime += TICK_INTERVAL_MS;
  }
}

In this code, I used an accumulated target position instead of moving a fixed number of steps every time. This is important because 1600 / 60 is not an integer. If I moved the same rounded step value every second, the error would accumulate over time. By calculating the target position from the total tick count, the final position stays more accurate.

Step 9: Final Assembly

After testing the linkage parts, the motor holder, and the electronics separately, I assembled the final prototype. The laser-cut wooden clock face was mounted to the support structure. The stepper motor was fixed behind the center using the motor holder.

The electronics were connected on a breadboard during this stage. The 12V power supply powered the motor driver, and the XIAO ESP32S3 sent control signals to the TMC2209.

Materials and Components

Problems and Solutions

What I Learned

This week helped me understand that mechanical design is not only about drawing shapes in CAD. The position of every hole, the clearance between moving parts, and the alignment of the motor shaft all affect whether the machine can move smoothly.

I also learned that a linkage mechanism should be tested manually before adding motor control. Manual testing helped me find friction, looseness, and alignment problems before the electronics were added.

Another important lesson was material selection. 3D printing was useful for customized fixing parts and early tests, while laser cutting was more efficient for producing many repeated flat linkage parts. Aluminum extrusion was useful for building a stable and adjustable support structure.

Reflection

This project connected mechanical design, digital fabrication, electronics, and programming. The result is a kinetic mechanical clock prototype that uses a physical mechanism to visualize time.

The clock is not only a time display, but also a mechanical visualization of time. The repeated linkage parts create a sculptural movement, and the stepper motor makes the movement controllable.

For the next version, I want to improve the center shaft structure, reduce friction between the linkage parts, make the wiring cleaner, and add a better user interface such as buttons or a web control page.

My Individual Contribution

My main contribution was the design and fabrication of the kinetic clock prototype. I researched the kinetic mechanical sculpture style, analyzed the linkage clock reference, tested the 3D printed linkage mechanism, prepared the laser-cut wooden linkage parts, designed the motor holder and center hand in Fusion 360, assembled the support structure, wired the stepper motor system, tested the clockwise and counterclockwise motor direction with the TMC2209 driver, and prepared the 60-second demo mode code for the next movement test.

Design Files

• Center hand STL: Download
• Stepper motor holder STL: Download
• 60-second demo mode Arduino code: Download