Here is a video of the project -

On Thursday, April 29^th, Jordan Mechner gave a talk at the NYU Game Center that spanned his entire career.  Mechner released his first hit game, Karateka, while he was an undergraduate student at Yale.  He started his most famous piece, Prince of Persia, before he finished school.  He later led the creation of The Last Express.  He was also a writer and designer on Prince of Persia: Sands of Time.  Finally, he wrote the script for the Disney-Buckheimer blockbuster movie based on his Prince of Persia series.  Below are a few tidbits from Mechner’s talk:

Writing For Movies Vs. Writing For Games

Mechner mentioned the difficulties in adapting a game story into a blockbuster movie.  When he was trying to convince Disney and Jerry Buckheimer to create a Prince of Persia movie, he did not show them the game’s original trailer; he created a new trailer, one that was less about actions the characters take and more about the interactions between the characters.  In the end, a game story needs follow a more action-oriented pace.  Movies, on the other hand, are much better at relationships between characters.

Programming Constraints

When creating the original Prince of Persia, Mechner did not plan on creating other characters.  The game was supposed to be about a single character, the Prince, moving through a castle.  Mechner had a good friend who kept insisting that he add enemies to the game, but he was out of memory.  He ended up creating the Shadow Prince, the first enemy he made for the game, because he figured out how, with a small change to the code, he could create a dark version of the Prince.  Mechner said that constraints created by the code often lead to better game design.

Game Design and Programming

About whether video game designers should learn how to program, Jordan Mechner said: “Wanting to make games without programming is like wanting to make movies and never wanting to touch a camera.”

Video of the game in action can be seen here (warning: the uncompressed video is 312 MB): http://dl.dropbox.com/u/10445954/SuperFlyVideo.avi

This sketch connects an analog sensor to Pachube (http://www.pachube.com)
using a Wiznet Ethernet shield. You can use the Arduino Ethernet shield, or
the Adafruit Ethernet shield, either one will work, as long as it’s got
a Wiznet Ethernet module on board.

This example has been updated to use version 2.0 of the Pachube.com API.
To make it work, create a feed with two datastreams, and give them the IDs
sensor1 and sensor2. Or change the code below to match your feed.

This example uses the String library, which is part of the Arduino core from
version 0019.

Circuit:

• Analog sensor attached to analog in 0
• Ethernet shield attached to pins 10, 11, 12, 13

created 15 March 2010
updated 16 Mar 2012
by Tom Igoe with input from Usman Haque and Joe Saavedra

http://arduino.cc/en/Tutorial/PachubeClientString

This code is in the public domain.

*/

#include <SPI.h>
#include <Ethernet.h>
#define APIKEY “hHJDUKi0wyPlbkwiGi-XihdqsCCSAKxjVjA3emFlRTJNZz0g” // replace your pachube api key here
#define FEEDID 57225 // replace your feed ID
#define USERAGENT “toilet brush 1.0″ // user agent is the project name

// assign a MAC address for the ethernet controller.
// fill in your address here:
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
// fill in an available IP address on your network here,
// for manual configuration:
IPAddress ip(10,0,1,20);

// initialize the library instance:
EthernetClient client;

// if you don’t want to use DNS (and reduce your sketch size)
// use the numeric IP instead of the name for the server:
//IPAddress server(216,52,233,122); // numeric IP for api.pachube.com
char server[] = “api.pachube.com”; // name address for pachube API

unsigned long lastConnectionTime = 0; // last time you connected to the server, in milliseconds
boolean lastConnected = false; // state of the connection last time through the main loop
const unsigned long postingInterval = 10*1000; //delay between updates to Pachube.com

int photocellPin = 0; // the cell and 10K pulldown are connected to a0
int photocellReading; // the analog reading from the analog resistor divider

int counter;
int timer;
unsigned long start;
unsigned long Total;
unsigned long finalTotal;
boolean checkFlag = false;
int lastphotovalue;
int flagTimer = 5000;

void setup() {
// start serial port:
Serial.begin(9600);
// give the ethernet module time to boot up:

counter = 0;
//pinMode(buttonPin, INPUT); //button
// pinMode(ledPin, OUTPUT); //LED
delay(1000);

// start the Ethernet connection:
if (Ethernet.begin(mac) == 0) {
Serial.println(“Failed to configure Ethernet using DHCP”);
// DHCP failed, so use a fixed IP address:
Ethernet.begin(mac, ip);
}
}

void loop() {

delay(10);
photocellReading = analogRead(photocellPin);
//Serial.print(“Analog reading = “);
//Serial.println(photocellReading);

//Serial.print(“checkFlag: “);
//Serial.println(checkFlag);
//Serial.print(“reading: “);
//Serial.println(photocellReading);
//Serial.print(“flagTimer: “);
//Serial.println(flagTimer);

//if (photocellReading > lastphotovalue + 50 && checkFlag == true && flagTimer > 3000) {
if (photocellReading > 250 && checkFlag == true && flagTimer > 3000 ){
Serial.println(” – Dark”);

counter++;
Serial.print(“counter: “);
Serial.println(counter);
Total = millis()-start;
finalTotal = Total /1000 ;
Serial.print(“finalTotal: “);
Serial.println(finalTotal);
checkFlag = false;
/* Serial.println();
Serial.print(“—– duration: “);
Serial.println(finalTotal);
Serial.print(“—– count: “);
Serial.println(counter);
Serial.println();
*/
String dataString = “duration,”;
dataString += finalTotal;

dataString += “\ndailyCount,”;
dataString += counter;

sendData(dataString);
}

// if (photocellReading +100 < lastphotovalue){

if(photocellReading < 150){

if(checkFlag == false){
Serial.println(” – Very bright”);
start = millis();
Serial.print(“start: “);
Serial.println(start);
}
//delay(500);
checkFlag = true;
}

flagTimer = millis() – start;

lastphotovalue= photocellReading;

// if there’s incoming data from the net connection.
// send it out the serial port. This is for debugging
// purposes only:
if (client.available()) {
char c = client.read();
Serial.print(c);
}

// if there’s no net connection, but there was one last time
// through the loop, then stop the client:
if (!client.connected() && lastConnected) {
Serial.println();
Serial.println(“disconnecting.”);
client.stop();
}

// if you’re not connected, and ten seconds have passed since
// your last connection, then connect again and send data:
// if(!client.connected() && (millis() – lastConnectionTime > postingInterval)) {
// Serial.println();
// Serial.print(“—– duration: “);
// Serial.println(finalTotal);
// Serial.print(“—– count: “);
// Serial.println(counter);
// Serial.println();
//
// sendData(dataString);
// }
// store the state of the connection for next time through
// the loop:
lastConnected = client.connected();
}

// this method makes a HTTP connection to the server:
void sendData(String thisData) {
// if there’s a successful connection:
if (client.connect(server, 80)) {
Serial.println(“connecting…”);
// send the HTTP PUT request:
client.print(“PUT /v2/feeds/”);
client.print(FEEDID);
client.println(“.csv HTTP/1.1″);
client.println(“Host: api.pachube.com”);
client.print(“X-PachubeApiKey: “);
client.println(APIKEY);
client.print(“User-Agent: “);
client.println(USERAGENT);
client.print(“Content-Length: “);
client.println(thisData.length());

// last pieces of the HTTP PUT request:
client.println(“Content-Type: text/csv”);
client.println(“Connection: close”);
client.println();

// here’s the actual content of the PUT request:
client.println(thisData);
}
else {
// if you couldn’t make a connection:
Serial.println(“connection failed”);
Serial.println();
Serial.println(“disconnecting.”);
client.stop();
}
// note the time that the connection was made or attempted:
lastConnectionTime = millis();
}

https://vimeo.com/42368214

http://a.parsons.edu/~petta518/dataSwirl/index.html

https://cosm.com/users/aapett

https://twitter.com/#!/DataSwirl

PRECEDENCES

Penbo - The Bossa Nova Penbo Interactive Penguin Robot is loveable interactive penguin that loves you and loves her baby.

Star Wars R2-D2 Interactive Astromech Droid - Bring home the Star Wars R2-D2 Interactive Astromech Droid to recreate and relive the magic of the epic, intergalactic saga.

Future Directions

+ physical and video games

+ controlling by people through internet (http://seaworldparks.com/en/seaworld-sandiego/Animals/Webcams/Penguin-Cam)

+ making a real robot can stand in south pole and helping penguins

Here are some pictures of the shell of the first iteration:

For the second iteration, I pulled out the electronics of the first and just added a new outer structure.  I also added sound.  Here are images of that version:

It was a fun process, and I liked using sound, which I haven’t done a whole lot of before.  I also like the idea of trying to convey different emotional states with just led lights.  That was much harder with the 8bit sound though, at least for me.  Maybe for future iterations of this kind of project I would buy a wave shield, or connect the project to a computer so that I could use Max/msp to control the sounds.

Here is a video of the final piece:

Here are some images of my heart box:

And heres a video of it blinking:

Caitlin Morris ++ Liza Stark

Glowing Hoop is the first part of a series of objects designed to remind adults to be playful.

The primary user audience are adults who are perpetually enmeshed in their professional or academic lives. Hopelessly addicted to the screen and seriousness of accomplishing a particular goal, these adults have forgotten the virtues of spontaneity and the merits of play. These objects seek to remind them of the importance of physical movement, mental breaks, and chance behavior to reinvigorate themselves and their process. Too often we become slaves to our practice: this is an attempt to break free of the entropy and shed our robot skins.

The hoop rests in a holder which is controlled by Arduino to rotate like a clock hand. After prolonged inactivity, the hand rotates, dropping the hoop to the ground and sparking action. An Arduino Mini on the hoop communicates with the holder via XBee, causing the hoop to start glowing different colors when the hoop falls off. An accelerometer in the hoop tells the holder when the hoop is spun, indicating a period of playful activity. The holder then returns to its original position and the lights go back to a solid color. The counter for inactivity is reset, restarting the cycle.

Iterations ++ Prior Art

Future Directions

In future iterations, we will focus on different types of LED behaviors, smaller hardware, and different patterns on the hula hoop itself. We would also like to explore spaces for potential installation and usage more in depth.

My video is here:

While the lamps worked well for a gallery installation, I still feel they’re too fragile and time consuming to be mass produced.  So I decided to start looking at other ways I could create them that would be faster and more reliable.  The first thing I investigated was getting pieces of Acrylic laser cut with where the circuit needed to go, so that I could either paint or embed the circuitry into the engraved areas of the acrylic.

I also worked on designing a different PCB from the one I’m currently using.  Here is the current PCB:

and here is the new triangular pcb and flexible joint that I designed:

I also requested quotes for getting a batch order of PCBs (with the triangle being rigid and the joint being flexible) to be printed and populated from the following 6 places:

but I only got two responses and only one quote.  Heres the quote I got:

It was interesting exploring the production side of this project, I’m still not sure if PCBs if the direction I’d like to go, but I’m glad I explored it.  Also, here is a link to the presentation I made in class.

In future iterations I would like to create a book with different backgrounds and animals, for example an owl that is awake (lights) during the night, so when the moon is in the sky the starts and owl lights up.
In this iteration I used conductive tape and it doesn’t work very good. For the next iteration I would use conductive Velcro so it’s easier for the children to put the sun and the moon in the sky.

PRIOR ART

WIRELESS BUTTERFLY

TAPESTRY

The first state is alarming: the lights are red and makes an alarming sound.
The second state is relaxing: the lights change from blue to light blue / pink without sound allowing the user to relax.
The third is a thinking mood, where the lights are blue and makes a “thinking” sound.