Clock of Clocks 288

by Lucas Lu

Conceptual Design

Final Construction

The Inspiration

When I first encountered the A Million Times clock, I was instantly captivated. Hundreds of independent hands dancing in perfect synchronization to form digits and waves—it felt like watching mechanical magic. However, the premium price tag was a significant barrier. Driven by curiosity and a “maker” spirit, I decided to build my own 24 x 12 matrix version from scratch.

System Architecture

This massive kinetic installation is powered by a distributed control network of 73 microcontrollers:

Master (Arduino Mega): The brain. It connects to NTP servers via WiFi to fetch precise time and maps it onto a 12×24 coordinate system. It manages 9 distinct animation patterns (Waves, Rectangles, Random patterns) and dispatches target positions to 72 slave nodes over the I2C bus.
Slaves (72x Arduino Nano): The muscle. Each Nano acts as an I2C slave node, controlling 4 dual-shaft stepper motors (8 independent hands per node). They handle high-frequency step generation and real-time sensor monitoring.

Engineering Breakthrough: Closed-Loop Calibration

        Standard stepper motors operate in an “open-loop” fashion. Without feedback, a single skipped step or power flicker would permanently de-sync the clock hands.
    

To solve this, I integrated a Hall Effect Sensor Matrix into the custom PCB. Each clock hand contains a tiny neodymium magnet, and two Hall sensors are positioned along its rotation path.

My V2.0 firmware implements a “Silent Calibration” logic: instead of a clunky global reset, the Arduino Nano monitors the exact moment the magnet passes the sensor. By calculating the average trigger position, the system determines the position_diff. If an error exceeding 2 degrees is detected, the slave node automatically compensates for the drift during its next movement, ensuring the array remains perfectly aligned 24/7.

Open Source & Code

This project is fully open-sourced for the geek community. Below are snippets of the logic managing the distributed time distribution and the real-time sensor feedback.

► Master Controller Logic (NTP to Matrix Mapping)

// Core logic: Mapping digits to the 12×24 array
void showDigits() {
  int h1 = currentTime.getHour() / 10;
  int m2 = currentTime.getMinutes() % 10;
  
  // Mapping predefined digit arrays to the global ‘base’ matrix
  for (int i = 0; i <= 5; i++) {
    for (int j = 0; j <= 4; j++) {
      base[i + 3][j + 1][0] = digits[h1][i][j][0];
      // ... further mapping for h2, m1, m2
    }
  }
  // Sending 8-byte position data to 72 slaves via I2C
  for (int i = 1; i <= 72; i++) {
    Wire.beginTransmission(i);
    Wire.write(sendData, 8);
    Wire.endTransmission();
  }
}

► Slave Feedback Logic (Hall Sensor Calibration)

// Core logic: On-the-fly calibration using Hall sensors
void loop() {
  // Read sensor state (Digital/Analog hybrid detection)
  tempVal = (digitalRead(hall_sensors[i]) == LOW) ? 1 : 0;
  
  if (tempVal != hall_flags[i]) {
    hall_flags[i] = tempVal;
    hall_positions[i][tempVal] = position_current[i];
    
    if (tempVal == 0) { // Triggered on magnet exit
      // Calculate deviation between physical and logical position
      position_diff[i] = STEPS – (hall_positions[i][0] + hall_positions[i][1]) / 2;
      
      // Apply offset compensation if threshold is met
      if (position_diff[i] > 24 && position_diff[i] < STEPS - 24) {
        position_current[i] = (position_current[i] + position_diff[i]) % STEPS;
      }
    }
  }
}