Halloween Cuckoo Clock

Team: Azin Mirzaagha, Patrick Barin, Yunjie Yao



Create a “Cuckoo Clock” mechanics. Cuckoo Clock typically has an automaton of the bird that appears through a small trap door while the clock is striking.


Components Used

  • Plywood
  • wood beams
  • wood pieces
  • rubber bands
  • Small hinge
  • wood squares
  • tape
  • Glue
  • Scissor


Halloween Cuckoo Clock


We created a Halloween theme cuckoo clock because this Wednesday is Halloween!!

When made a house, and when the door of the house is opened, a pumpkin will pop out with a message “trick or treat”!



Update: Video Link! https://goo.gl/photos/qU17V29jDkocHKya6


Our instrument is a group of five robots that each have their own percussive abilities. They are 1.) a four armed tap-bot that has four servos that tap tap tap on things, 2.) a two-armed spinning bot that hits things with it’s metal hands to make noise, 3.) a rolling pinecone that makes a rumbling noise on it’s surface, 4.) a shepard with a tap-tapping staff, and 5.) a scraper-bot that uses a bristly brush to scrape things and make noise.

We mounted 4/5 of them on a turning lazy susan, with the intention of making customization possible by changing the things on which the robots are tapping. (We could rotate the lazy susan to change what object each robot was tapping on.)

Our robots are controlled by a control board with 5 pots. They control: 1.) the tempo of the music that our bots make, 2.) the pattern with which the pine cone rolls, 3.) the pattern with which the scraper scrapes, 4.) the pattern with which the shepard taps, and 5.) the speed with which the spinny bot spins.

Challenges included: 1.) Getting the robots to tap with similar patterns // with some semblance of coherent synchrony, 2.) getting the different settings of the pots to have noticeably different sounds.

Materials Used:
– 2 Arduinos
– 4 Micro-servos
– 3 normal servos
– 3D printed plastic
– lots! of jumper wires
– machine screws / nuts
– beer bottle
– 3 soda cans
– pine cone
– chopsticks
– 5 pots
– laser cut control board, pinecone eyes, lazy susan parts
– construction paper
– foam ball
– clay
– DC motor
– metal wire
– metal bolts/nuts from Dan’s bed
– wire brush
– metal marbles
– chipotle tin
– cardboard scrapey surface w/ packaging material
– diode
– resistors
– breadboard
– 3 battery packs
– rubber bands


#include <Servo.h> 

Servo myservoR;
Servo myservoRp;
Servo myservoL;
Servo myservoLp;
Servo servoLeah;
Servo servoAndrew;
Servo servoJake;
int deltaPot = 0;

int leahPot = 1; 
int leahBeat = 0;

int andrewPot = 2; 
int andrewBeat = 0;
int danielPot = 3;
int danielBeat = 0;

int jakePot = 4;
int jakeBeat = 0;

int pos = 0; // variable to store servo position 

void setup() 
 Serial.begin(9600); // setup serial
 myservoR.attach(4); //Rightmost arm from point of view of the crab
 myservoRp.attach(5); //Right-sub-prime (right arm of the left crab)
 myservoL.attach(6); //Leftmost arm from point of view of the crab
 myservoLp.attach(7);// "Left-sub-prime" (left arm of the right crab)
void loop() {

 int delta = potCipher(analogRead(deltaPot))*2; //speed of the hammering
 Serial.print("delta: ");

 servoAndrew.write(80); //ARMS UP!!!

 andrewBeat = potCipher(analogRead(andrewPot));
 Serial.print("andrewBeat: ");

 danielBeat = potCipher(analogRead(danielPot));
 Serial.print("danielBeat: ");
 jakeBeat = potCipher(analogRead(jakePot));
 Serial.print("jakeBeat: ");

 leahBeat = potCipher(analogRead(leahPot));
 Serial.print("leahBeat: ");
 for (int i=0; i <= 400; i++){
 servoAndrew.write(getArmLoc(pos, andrewBeat)); 
 servoLeah.write(getArmLoc(pos, leahBeat)); 
 servoJake.write(getArmLoc(pos, jakeBeat));
 myservoR.write(abs(abs(80-pos)-80)); //This series SHOULD do 16th-notes, approximately... but it sounds a bit off, so my math might be wrong
 pos += delta;

 if (pos >= 160) pos=0;


int getArmLoc(int pos, int beatType) {
 if (beatType == 1) {
 return abs(abs(80-pos)-80);
 else if (beatType == 2) {
 return abs(abs(40-pos)-80);
 else if (beatType == 3) {
 return abs(abs(80-(abs(pos-60)))+100);
 else if (beatType == 4) {
 return abs(abs(80-(abs(pos-80)))+100);

// returns a potSection value based on the position of the pot
int potCipher(int potVal) {
 int potSection;
 if (potVal >= 0 && potVal <= 205) {
 potSection = 0; 
 else if (potVal >= 206 && potVal <= 410) {
 potSection = 1;
 else if (potVal >= 411 && potVal <= 615) {
 potSection = 2;
 else if (potVal >= 615 && potVal <= 820) {
 potSection = 3;
 else {
 potSection = 4;
 return potSection;

Spookoo Clock

Video:  https://youtu.be/ukvsB9rwcKE


Our group’s ideas ranged far and wide for this one, but after considerable debate we realized we wanted to create a project with at least the following characteristics:

  1. Halloween themed, with a
  2. Nontraditional door, and which
  3. Respects the cuckoo-clock MO

With these parameters in mind our project became clear to all of us all at once: an egg that hatches a skeleton cuckoo bird through an egg shell door.

We started with a cardboard model, which we then measured and recreated in Fusion 360. For our hinge and door mechanism we decided to employ a “living hinge” design that we laser cut from plywood. We actuated the door with a gear and crank glued to the inside of the box, and added a second gear to drive a rack at the base of our bird design. As the gears turn the bird is propelled upwards and the lid opens.

We had some ideas about how to give the bird some personality, too, by having it “peep” when it reached the top of its stroke. We were able to do this on a timer, and had plans to incorporate a microphone so that a loud noise would startle the bird out of its shell. While we did include the mic in our schematic, a little more work is needed on the code to get that particular functionality set up.


Plywood, 1/8″

Small servo motor


Arduino Uno

Wood glue

Machine screws

SparkFun Mic


Piezo Speaker



/* Sweep
by BARRAGAN <http://barraganstudio.com>
This example code is in the public domain.

modified 8 Nov 2013
by Scott Fitzgerald

#include <Servo.h>

Servo myservo; // create servo object to control a servo
// twelve servo objects can be created on most boards

int pos = 0; // variable to store the servo position
const int sampleWindow = 250; //250 MS sample width
unsigned int loudNoise;
int speakerPin = 7;
int val = 0;
int orig = 0;
int potPin = 0;
void setup()
pinMode(speakerPin, OUTPUT);
myservo.attach(9); // attaches the servo on pin 9 to the servo object

void loop() {
unsigned long start= millis(); // start of sample window
unsigned int peakToPeak = 0; // peak-to-peak level
unsigned int signalMax = 0;
unsigned int signalMin = 1024;

while (millis() – start < sampleWindow) // collecting data for 250 MS (can be changed)
loudNoise = analogRead(0);
if (loudNoise < 1024) //
if (loudNoise > signalMax) // if there’s a loud noise, save the loud value
signalMax = loudNoise;
else if (loudNoise < signalMin) // if there’s not a loud noise, don’t save the loud value
signalMin = loudNoise;

peakToPeak = signalMax – signalMin; // max – min = peak-peak amplitude
double volts = (peakToPeak * 3.3) / 1024; // convert to volts
Serial.println(volts); // to know if the mic is working

// digitalWrite(speakerPin, LOW);

//val = analogRead(potPin); // read value from the sensor
//val = val*30; // process the value a little
//val = val/2; // process the value a little

if (volts >=1.0){
for( int i=0; i<50; i++ ) { // play it for 50 cycles
for(pos = 180; pos>=0; pos-=9) // goes from 180 degrees to 0 degrees
myservo.write(pos); // tell servo to go to position in variable ‘pos’
delay(15); // waits 15ms for the servo to reach the position

for(pos = 0; pos <= 180; pos += 3) // goes from 0 degrees to 180 degrees
{ // in steps of 1 degree
myservo.write(pos); // tell servo to go to position in variable ‘pos’
delay(80); // waits 15ms for the servo to reach the position
for(int j=0; j<50; j++){

digitalWrite(speakerPin, HIGH);
digitalWrite(speakerPin, LOW);

//if (volts >=1.0) {

// delay(2000); // for a certain amount of time (though this could be modified for more expressive behavior)
// Serial.println(“YELLING AT US”);
// }
// else {
// digitalWrite(12, LOW);
// digitalWrite(2, LOW); //not yetlling at us
// };
else {


Amazon Box Cuckoo Clock

Team: Neera, Olivia, Mudit, Michelle

We built a cuckoo clock out of an Amazon box. The basic idea is that the bird sits on a stick arrangement that has a rubber band attached to it. When the stick is pushed outward, it pushes the door open and the rubberband slacks. On the other hand, when the stick is pulled back in, the rubber band gets stretched and pulls the door shut due to the tension it develops. We built rails around the stick to guide it more accurately and allow for more control in addition to smoother operation.

We are happy that we were able to overcome Design Fixation in our design as the concept and the look are quite different from the sample we saw in class. We approached the problem afresh from the grassroot level and figured out the whole mechanism. This realization became even more prominent when we were made aware that our cuckoo clock has just one door unlike the one in shown in class which had two doors. We had a lot of fun putting it together and are excited to share it at the showcase tomorrow.

Cuckoo Clock TUI

make action GIFs like this at MakeaGif

Release the Kraken

Group Members:
Vivian Liu
Elena Duran
Andrew Chong

For our cuckoo clock, we built a simple reverse linkage to translate the backwards motion into sending the bird forward. Vivian used the laser-cutter to get the wood in the dimensions we needed, and drilled holes to put in the pivots. We attached it to the box by threading through the hole with chopsticks. We also added chopsticks (and pipe-cleaners) so that the linkage didn’t shift up, down, left or right too much.

We played around with different configurations until we decided to flip the box around and have the door open outwards and up (kind of like a pen where you would keep an animal). We had a lot of difficulty translating the backwards motion into the more diagonal motion of the string, and added little wheel pulleys along the top to help adjust the direction and motion of the string to the right angle.

We also experimented with rubber bands to have the clock “reset” itself automatically, so that our pulling motion would create tension in the rubber band, returning to its original position once we let go.




Backward/Forward Crawler

For my crawler, I originally created a wheel with many “knees” so that only the forward option would bite into the ground, with the backward motion only causing each joint to close. However, it only went around in circles.

To get around that, I tried playing around with the design so that motion would be forward and backwards. I tried making a larger forward leg to see if the uneven legs would cause the crawler to move forward if a peg attached to the motor struck the forward and backward leg.

Then I tried placing a large rubber band across the center and have the motor tense and relax the tension of the rubber band. Unfortunately I did not succeed – the crawler stands motionless.


Cuckoo Clock Lab


Nisha Pathak
Leah Rosenbaum
Owen Hsiao
Daniel Chen

For this lab, our task was to build “Cuckoo Clock” mechanics. We first drew out specifications for the doors that would open and close using one mechanism. We also wanted the bird’s movement to come from that same force. Initially, our plan was to build sliding doors that would open after pulling a string that was attached to the doors using hooks we created. However, the sliding doors needed stability which we thought could be provided by placing the stationary and moving doors on the same track. But, we found that there was too much friction between the tracks and the bottom and tops of the doors and we couldn’t open the doors in a seamless fashion. What’s more, we found that the hooks we created weren’t stable enough to open the doors. We chose to reevaluate our plan and instead, built a mechanism that would simultaneously push the bird out and open the doors outward. We built stationary boards (supported by “L” shaped pieces of cardboard) to which we connected the doors that would actually open. Using rubber bands and push pins, we adjusted the elasticity of the bands so that the doors would open with ease and would close on their own. The bird was attached to a flat, triangulated piece of cardboard and both of these pieces were connected to a small, wood beam. Using a small hinge, we attached this beam to another piece of wood and created a lever to push the bird through the doors. The lever was attached to a stack of wood pieces and is held together with a rubber band. Finally, in order to get the height we needed, we placed this entire mechanism on top of a tissue box.


  •      4 wood pieces (6” x 4”)
  •      4 rubber bands
  •      2 small wood beams (1.2” x 6”)
  •      3 wood squares (4”x 3”)
  •      Push pins
  •      Masking tape
  •      Small hinge
  •      Tissue box
  •      Glue
  •      Saw

img_7470 img_7472



Trapdoor Cuckoo Clock


Our group wanted to attempt an unconventional cuckoo clock, counter to the example we saw in class with the 4-bar joint. Instead of a cuckoo that emerged horizontally from the door, we designed a cuckoo that plunged through a trapdoor instead. The primary mechanism used to move the trapdoor and lower the cuckoo through the opening is a pulley system. As the pulley is pulled in one direction, the trapdoor moves out of the way to reveal an exit. As the pulley is pulled and the trapdoor is moved back, the cuckoo also lowers. The cuckoo is mitigated from falling outside the bounds of the trapdoor exit until the opening is wide enough for it to plunge through. The cuckoo can then continue to be lowered, or reigned back into the clock by pulling the pulley in the opposite direction. The trapdoor is prevented from collapsing on the cuckoo prematurely by means of (1) the distances used in both the strings affixed to the door and the cuckoo, and (2) the rotational distance between the door and the peg that pushes it back into place.

To hold the system in place and direct accurate movement, we have in place four poles around the trapdoor’s perimeter (but not affixed to the trapdoor). These poles are taped securely to the surface of the foam board/clock base. While there are three gears in our structure, only the center one is unrestrained by a foundational support component. For our design, it is imperative that thread lines are measured to have sufficient tension and slack when appropriate. Otherwise, the system will fail. If the support structure also shifts (whether at foundation or at suspension), the system is likely to fail due to the shifting of the trapdoor in and out of place. Also necessary is a wall to prevent the cuckoo from traveling with the trapdoor as it slides back, as opposed to falling through the exit.

We think this cuckoo clock mechanism design is appropriate, considering the majority of cuckoo clocks hang on the wall, and so have room beneath them that can be utilized.

Components Used:

  • 7 gears (4 for foundational support, 2 for suspended support, 1 for pulley system)
  • 1 long stick
  • 2 mid-length sticks
  • 5 short sticks (sizes must be relative; 3 for pulley system)
  • 1 cuckoo (made out of a spool, suspended by string)
  • two cuts of string (1 for the trapdoor, 1 for the cuckoo)
  • 1 relatively large piece of balsa wood for the trapdoor
  • 3 relatively narrow pieces of balsa wood for support/error-prevention
  • 1 T-pipe
  • 2 straight joints with medial socket
  • 1 claw
  • 1 foam board sheet
  • duct tape
  • X-acto knife and cutting board
  • sufficient string for the pulley system


img_6360 img_6359

Let’s crawl


It was hard to derive linear motion out of a motor whose direction of rotation alternates. Initially I tried to design shoes out of erasers but it turns out the friction was too much for it to begin moving. The video for this attempt can be found here – https://goo.gl/photos/QXmh7DSLDyzkFmXM8


To fix this problem, I tried removing the feet and reworked the placement of wires. I got something which moves a little but only on a rough surface like that of a carpet or a rug – https://goo.gl/photos/5Jiy4hLLPD3BEsbm6



Arduino Board
Bread board
Servo motor


 * Servo with Potentiometer control
 * Theory and Practice of Tangible User Interfaces
 * October 11 2007

int servoPin = 7;      // Control pin for servo motor
int potPin   = 0;      // select the input pin for the potentiometer

int pulseWidth = 0;    // Amount to pulse the servo
long lastPulse = 0;    // the time in millisecs of the last pulse
int refreshTime = 20;  // the time in millisecs needed in between pulses
int val;               // variable used to store data from potentiometer

int minPulse = 500;   // minimum pulse width

void setup() {
  pinMode(servoPin, OUTPUT);  // Set servo pin as an output pin
  pulseWidth = minPulse;      // Set the motor position to the minimum
  Serial.begin(9600);         // connect to the serial port
  Serial.println("servo_serial_better ready");

void loop() {
  val = analogRead(potPin);    // read the value from the sensor, between 0 - 1024
  if (val > 0 && val <= 999 ) {
    pulseWidth = val*2 + minPulse;  // convert angle to microseconds
    Serial.print("moving servo to ");
  updateServo();   // update servo position

// called every loop(). 
void updateServo() {
  // pulse the servo again if the refresh time (20 ms) has passed:
  if (millis() - lastPulse >= refreshTime) {
    digitalWrite(servoPin, HIGH);   // Turn the motor on
    delayMicroseconds(pulseWidth);  // Length of the pulse sets the motor position
    digitalWrite(servoPin, LOW);    // Turn the motor off
    lastPulse = millis();           // save the time of the last pulse

The Chopstick Bot

To make a crawler, the first thing that came into my mind was chopsticks. So I gather a few chopsticks, break them, and them try to put them together in a way that would make the single-legged servo motor crawl. It took some observation and reiteration. I used a lot of tapes and a few coins to adjust the balance. Now this robot is really crawling.. but not in a straight line.. It seems to be moving towards Northwest…


Arduino Code

#include <Servo.h> //add servo library

Servo myservo; 

int pos = 0; // variable to store the servo position

void setup() {
myservo.attach(9); // attaches the servo on pin 9 to the servo object

void loop() {
for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees
// in steps of 1 degree
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(4); // waits 15ms for the servo to reach the position
for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(4); // waits 15ms for the servo to reach the position