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.

Materials:

Plywood, 1/8″

Small servo motor

Wires

Arduino Uno

Wood glue

Machine screws

SparkFun Mic

Breadboard

Piezo Speaker

 

Code:

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

modified 8 Nov 2013
by Scott Fitzgerald
http://www.arduino.cc/en/Tutorial/Sweep
*/

#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);
Serial.begin(9600);
Serial.println(“ready”);
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;
Serial.print(“loudNoise”);
Serial.print(loudNoise);
Serial.println();

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);
//myservo.write(180);

//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

};
delay(6000);
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
};
delay(500);
for(int j=0; j<50; j++){

digitalWrite(speakerPin, HIGH);
delayMicroseconds(800);
digitalWrite(speakerPin, LOW);
delayMicroseconds(800);
};

};
}
//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 {
myservo.write(0);
delay(1000);
}
};

 

20161026_040041 20161026_040150 20161026_040154 20161026_040113 20161021_192202 20161021_181655

Crawler with Servo Motor

Description

For this mini project, I used one servo motor and tested with different geometries and two different cardboard directions to come up with this mini cardboard crawler. I also played around with different combinations of the paper box and the servo motor to optimize the location of center of gravity to avoid the crawler turning over in the process of crawling

Components

  • 1 Bread Board
  • 1 Arduino Uno
  • 1 Futaba Servo Motor
  • 1 Box
  • 1 Green Wire
  • Transparent Tape
  • Jumper Wires
<strong>Code</strong>
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 &gt; 0 &amp;&amp; val &lt;= 999 ) {
 pulseWidth = val*2 + minPulse; // convert angle to microseconds
 
 Serial.print("moving servo to ");
 Serial.println(pulseWidth,DEC);
 
 }
 updateServo(); // update servo position
}

// called every loop(). 
void updateServo() {
 // pulse the servo again if the refresh time (20 ms) has passed:
 if (millis() - lastPulse &gt;= 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
 }
}
Image & Video

img_1012

img_1013

img_1015

DC motor and Dancing Wires

Description

For this mini project, I made a small installation where people can control the rotational speed of dancing wires and see the change in the form of the dancing wires as the speed changes.

Components

  • Arduino Uno
  • Wires
  • 1 Potentiometer
  • 1 DC motor
  • Batteries
  • 1 Resistor
  • 1 Diode
  • 1 Transistor
  • Tape

Code

int potPin = 0; // select the input pin for the potentiometer
int motorPin = 9; // select the pin for the Motor
int val = 0; // variable to store the value coming from the sensor
void setup() {
 Serial.begin(9600);
}
void loop() {
 val = analogRead(potPin); // read the value from the sensor, between 0 - 1024
 Serial.println(val);
 analogWrite(motorPin, val/4); // analogWrite can be between 0-255
}
Images

The whole connected device:

img_0943

The wires dancing at different radiuses, when the rotational speed of the  DC motor changes:

img_0944 img_0952 img_0948 img_0957

 

 

 

Arduino Lamp Photocell Serial Control with Bottle Cork

Description

I’m interested in how to push certain part of a system to create changing outputs over the time. With this in mind, for this project, I tried to mimic a serial lighting input environment for the photocell sensor, by making a paper bottle cork which is long enough to cover the photocell entirely inside. In this way, if I push and pull the hollow bottle cork, it can cover the photocell from the outside lighting from 100% to 0%. However, since white paper is actually semi-translucent to light, so I decide to use black paper to make the bottle cork, which is designed to be an excellent shading barrier for the photocell.

Components

  • 1 paper diffuser
  • 1 black bottle cork
  • Arduino uno
  • wires
  • 1 LED
  • 1 photocell
  • 2 resistors
  • 1 laptop

 

Code

int sensorPin = A0; 
int ledPin = 13; 
int sensorValue = 0; 

void setup() {
 // declare the ledPin as an OUTPUT:
 pinMode(ledPin, OUTPUT);
}

void loop() {
 // read the value from the sensor:
 sensorValue = analogRead(sensorPin);
 // turn the ledPin on
 digitalWrite(ledPin, HIGH);
 // stop the program for &lt;sensorValue&gt; milliseconds:
 delay(sensorValue*5);
 // turn the ledPin off:
 digitalWrite(ledPin, LOW);
 // stop the program for for &lt;sensorValue&gt; milliseconds:
 delay(sensorValue*5);
}
 

Video

 

Photos

img_0910 img_0911 img_0914 img_0915

 

FSR + PhotoCell

For this lab project, I tried to use both FSR and PhotoCell to feed in multiple streams of changing data to Processing. Along with the blinking change of LED light, the ball on the screen can also change accordingly, in terms of color, size, and location on the screen.

For the mechanical part, I tried hand, foam, and a small bean-bag ball, and it’s amazing even for bean ball it works to transform the force from my squeezing hand to the FSR. Perhaps force could be transmitted evenly across the material I chose?

I also found it challenging to figure out how to feed more than one data to Processing, and that’s why I ended up using 1 FSR for this lab. I want to consult with someone who has experience to push this further.

Materials:

  • 1 Arduino Uno
  • Wires
  • 2 Resistors (220 Ohms, 10k Ohms)
  • 1 LED
  • 1 FSR
  • 1 Small Bean-Bag Ball

Arduino Code

int sensorPin = A0; // select the input pin for the potentiometer
int val = 0; // variable to store the value coming from the sensor
int ledPin = 13; // select the pin for the LED

void setup() {
 // declare the ledPin as an OUTPUT:
 pinMode(ledPin, OUTPUT);
}

void loop() {
 // read the value from the sensor:
 val = analogRead(sensorPin);
 // turn the ledPin on
 digitalWrite(ledPin, HIGH);
 // stop the program for &lt;sensorValue&gt; milliseconds:
 delay(val);
 // turn the ledPin off:
 digitalWrite(ledPin, LOW);
 // stop the program for for &lt;sensorValue&gt; milliseconds:
 delay(val);
 Serial.println(val);//I tried to use 1 photoCell and 1 FSR, but I couldn't figure out how to send 2 data at the same time
}

Processing Code
* Arduino Ball Paint
 * (Arduino Ball, modified 2008)
 * ---------------------- 
 *
 * Draw a ball on the screen whose size is
 * determined by serial input from Arduino.
 *
 * Created 27 September 2016
 * Edited by Safei Gu
 */
import processing.serial.*;
// Change this to the portname your Arduino board
String portname = "/dev/cu.usbmodem1411"; // or "COM5"
Serial port;
String buf="";
int cr = 13; // ASCII return == 13
int lf = 10; // ASCII linefeed == 10

int serialVal = 0;

void setup() {
 size(300,300);
 frameRate(10);
 smooth();
 background(40,40,40);
 noStroke();
 port = new Serial(this, portname, 9600); 
}

void draw() {
 // erase the screen
 background(40, 40, 40);

// draw the ball
 fill(serialVal/100, serialVal/100, serialVal/100);
 ellipse(serialVal/30,serialVal/30,serialVal-50,serialVal-50);
}

// called whenever serial data arrives
void serialEvent(Serial port) {
 int c = port.read();
 if (c != lf &amp;&amp; c != cr) {
 buf += char(c);
 }
 if (c == lf) {
 serialVal = int(buf);
 println("val="+serialVal); 
 buf = ""; 
 }
}
 

Images

img_0867

[RR04] Ambient Design Examples

It’s very interesting when I tried to think about ambient examples, the first one that came to my mind is actually quite a traditional example, which is almost everywhere today. I would argue that ambient design isn’t some concept that is entirely without industrial design background. This very first example I thought about is the smoke detector in almost every house in U.S. today. Why I think that’s a great example of ambient design? Several reasons are because of it being able to switch to the user’s main attention of focus, and being able to switch back to the background during the most of the time, and providing normally non-critical information, which is “no alarm”.

With that, we could even argue that the natural environment we are nested in could also be a huge ambient information system. If it rains a little bit today, your windows at your house would give you a little bit of visual hint of the traces of raindrops. This might be drag-to-attention information, but not such a piece of information that would require immediate attentions. But if there is a storm today, your windows will give you much more visual hint of dynamic raindrops running down the glass surface, you will also be able to hear the large sound of the rain dropping on the window, and there could even be thunders dragging to your attention. And this will require more immediate reactions, such as checking if your family members who are still outside are ok or not, and if you’re heading out, then you would be looking for rain gear immediately.

With this thinking, I remember a PARV paper discussed about how they imagined ubiquitous design several decades ago, and in their fictional narrative story of Sai, who lives in a ubiquitously designed house, could be able to look into his glass window of the house, and read the emerging information on the window surface about buses, his neighbors activities, etc. Isn’t this digital example actually a translated usage of the windows giving people ambient information in daily context?

Reflection on Fishkin’s Taxonomy

I think Fishkin’s taxonomy is helpful in understanding the UIs mentioned in the paper, in terms of embodiment and metaphor. However, there are a lot of other types of UIs left out of the taxonomy that Fishkin’s taxonomy could not be very helpful to help people understand.

For example, his taxonomy on the embodiment axis didn’t discuss the distance between human body and the input device at all. TUI doesn’t need to be literally using hands to do input. For example, we could have Siri or Echo as part of the TUI input system.

Another issue about Fishkin’s taxonomy is his metaphor axis, which only considers the shape and the motion. I think the metaphor concept could be pushed much further. For example, the taxonomy on the metaphor axis could also include all the other human senses other than sight, such as taste, touch, smell, and sound.

Moreover, I would suggest the metaphor axis could also include personality, for people to understand more robot-type TUI systems, such as Baymax in the movie of Big Hero 6.