TOP Mockumentaries

A Mighty Wind:

Mockumentary captures the reunion of 1960s folk trio the Folksmen as they prepare for a show at The Town Hall to memorialize a recently deceased concert promoter.

Best In Show:

Best in Show is presented as a documentary of five dogs and their owners destined to show in the Mayflower Kennel Club Dog Show, held in Philadelphia. The documentary jumps between the owners as they prepare to leave for the show, arriving at the hotel, and preparing backstage before their dog takes the show.

The Blair Witch Project:

In October of 1994 three student filmmakers disappeared in the woods near Burkittsville, Maryland, while shooting a documentary…A year later their footage was found
Borat:
Kazakh TV talking head Borat is dispatched to the United States to report on the greatest country in the world. With a documentary crew in tow, Borat becomes more interested in locating and marrying Pamela Anderson.
CB4:
A “rockumentary”, covering the rise to fame of MC Gusto, Stab Master Arson, and Dead Mike: members of the rap group “CB4”
Fubar:
Terry and Dean are lifelong friends who have grown-up together: shotgunning their first beers, forming their first garage band, and growing the great Canadian mullet known as “hockey hair”. Now the lives of these Alberta everymen are brought to the big screen by documentarian Ferral Mitchener in an exploration of the depths of friendship, the fragility of life, growing up gracefully and the art and science of drinking beer like a man.
Man Bites Dog:
A camera crew follows a serial killer/thief around as he exercises his craft. He expounds on art, music, nature, society, and life as he offs mailmen, pensioners, and random people. Slowly he begins involving the camera crew in his activities, and they begin wondering if what they’re doing is such a good idea.
REC:
“REC” turns on a young TV reporter and her cameraman who cover the night shift at the local fire station. Receiving a call from an old lady trapped in her house, they reach her building to hear horrifying screams — which begin a long nightmare and a uniquely dramatic TV report.
The Grand:
An improvisational comedy using a handful of actors playing characters competing in an actual poker tournament.

This Is Spinal Tap:
Marti DeBergi is a film-maker who decides to make a documentary, a rockumentary actually, about the world’s loudest band, the British heavy metal group Spinal Tap. The movie is in fact a biting satire and spoof of the whole rock and roll scene that passes itself off as a real documentary of a real band.
All these films give me an idea of the style for example shooting and editing styles that may be used in the making of our film.
Advertisements

February 22, 2010. Uncategorized. Leave a comment.

Navigation

-Navigation Should Be Easy to Find

-Keep it Consistent

-Use Obvious Section Name

-Less is More

-Remind the User Where They Are

Navigation Should Be Easy to Find:

Navigation has to be clearly visible, located typically on top of page

Keep it Consistent:

Clear and  standard throughout
Use Obvious Section Names:
Choice of section names should be obvious
Less is More:
Keep to a minimum
Remind the User Where They Are:
Key that navigation is well laid out

February 22, 2010. Uncategorized. Leave a comment.

Mockumentary Websites

Here are some of the many websites iv been researching. All are mostly visual that focus on similar aspects  throughout. For example: DVD sale , cast, story, trailer, behind the scenes etc  all aspects we would like to incorrporate into our website.

February 20, 2010. Uncategorized. Leave a comment.

Networked Arduino Heartbeat Sensor

EXTREMELY INTERESTING PROJECT!!

This is the type of thing that could be used so well with our project. Because Arduino is picking up the heart beat we could use this to control the pace of imagery or video or light or sound.

Networked Arduino Heartbeat Sensor Code

I wanted it to communicate with the computer and send data to SuperCollider. As a proof of concept, I’ve connected the Arduino to SuperCollider via a Processing script that translates serial data from the Arduino into OSC messages.

WATCH VIDEO!

Arduino Heartbeat Sensor - Demo with Processing and SuperCollider

The sensor uses two simple components, an IR LED and an IR phototransistor. Both components are powered by the Arduino’s 5V output and one analogue input reads the voltage across the phototransistor.

1. IR LED (Jaycar ZD1945)
2. IR Phototransistor (Jaycar ZD1950)
3. 10KOhm resistor
4. 220Ohm resistor

The simple circuit is the same as for an IR range sensor, commonly used in robot projects. The easiest way to start looking at data form an Arduino’s analogue input is to follow the Arduino Graph tutorial.

The idea is that when your heart beats you have a quick rush of blood into tiny blood vessels close to your skin which makes it less transparent. This effect is easiest to observe on your finger tips or earlobe. So the IR emitter and phototransistor are placed next to each other (not much light goes through the side of the emitter!) and I put my finger on top. Light from the IR emitter illuminates my skin and is reflected into the phototransistor.

The phototransistor is connected to the Arduino in a similar way to a potentiometer. One lead is connected to +5V and the other to ground. The +5V lead is also connected to an analogue input on the Arduino. When the phototransistor receives more IR light it becomes more resistive and a lower voltage is detected by the analogue input.

The circuit all soldered together and held together with double sided tape. It was then wrapped up in electrical tape to protect it and shield the phototransistor from other light sources.

Graph of the sensor output! Each little bump is a heartbeat!

Similar projects around the internet have used an amplifier to boost the signal from the phototransistor. I found that the data was clear enough for the Arduino to track heartbeats accurately. My Arduino program follows the (average) rate of change of the phototransistor voltage and uses this to judge whether a heartbeat is occuring or not.

// cpm_heartbeatEthernet
// Version 1.0 October 2009.
// Copyright Charles Martin (http://www.charlesmartin.com.au).
// Uses recotana’s OSCClass (http://www.recotana.com)

// Detect heartbeat using a light reading through skin
// On each beat, send an OSC message of the instantaneous
// heartrate.

#include “Ethernet.h”
#include “OSCClass.h”

// Pins
const int ledPin = 13;
const int sensePin = 0;

// LED blink variables
int ledState = LOW;
long ledOnMillis = 0;
long ledOnInterval = 50;

// Hearbeat detect variables
int newHeartReading = 0;
int lastHeartReading = 0;
int Delta = 0;
int recentReadings[8] = {0,0,0,0,0,0,0,0};
int historySize = 8;
int recentTotal = 0;
int readingsIndex = 0;
boolean highChange = false;
int totalThreshold = 2;

// Heartbeat Timing
long lastHeartbeatTime = 0;
long debounceDelay = 150;
int currentHeartrate = 0;

// Ethernet and OSC information
byte serverMac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte serverIp[] = { 192, 168, 0, 99 };
int serverPort = 10000;
// byte gateway[] = { 192, 168, 0, 1 };
// byte subnet[] = { 255, 255, 255, 0 };
byte destIp[] = {192,168,0,255};
int destPort = 3333;
char *topAddress=”/heartbeat”;
OSCMessage recMes;
OSCMessage sendMes;
OSCClass osc(&recMes);

void setup() {
Ethernet.begin(serverMac ,serverIp);
osc.begin(serverPort);
osc.flush();
sendMes.setIp( destIp );
sendMes.setPort( destPort );
sendMes.setTopAddress(topAddress);
// initialize the serial communication:
Serial.begin(9600);
// initialize the digital pin as an output:
pinMode(ledPin, OUTPUT);
}

void loop() {
// Turn off LED
digitalWrite(ledPin, LOW);

// Read analogue pin.
newHeartReading = analogRead(sensePin);
//Serial.println(newHeartReading);
//Calculate Delta
Delta = newHeartReading – lastHeartReading;
lastHeartReading = newHeartReading;

// Find new recent total
recentTotal = recentTotal – recentReadings[readingsIndex] + Delta;
// replace indexed recent value
recentReadings[readingsIndex] = Delta;
// increment index
readingsIndex = (readingsIndex + 1) % historySize;

//Debug
//Serial.println(recentTotal);

// Decide whether to start an LED Blink.
if (recentTotal >= totalThreshold) {
// Possible heartbeart, check time
if (millis() – lastHeartbeatTime >= debounceDelay) {
// Heartbeat
digitalWrite(ledPin, HIGH);
currentHeartrate = 60000 / (millis() – lastHeartbeatTime);
lastHeartbeatTime = millis();
// Print Results
//Serial.println(“Beat”);
if (currentHeartrate <= 200) { Serial.println(currentHeartrate); // Send a serial message sendMes.setArgs(“i” , &currentHeartrate); // Setup an OSC message osc.sendOsc( &sendMes ); // Send the heartbeat OSC message } } } delay(10); }

Arduino code:

// Pins
const int ledPin = 13;
const int sensePin = 0;

// LED blink variables
int ledState = LOW;
long ledOnMillis = 0;
long ledOnInterval = 50;

// Hearbeat detect variables
int newHeartReading = 0;
int lastHeartReading = 0;
int Delta = 0;
int recentReadings[8] = {0,0,0,0,0,0,0,0};
int historySize = 8;
int recentTotal = 0;
int readingsIndex = 0;
boolean highChange = false;
int totalThreshold = 2;

// Heartbeat Timing
long lastHeartbeatTime = 0;
long debounceDelay = 150;
int currentHeartrate = 0;

void setup() {
// initialize the serial communication:
Serial.begin(9600);
// initialize the digital pin as an output:
pinMode(ledPin, OUTPUT);
}

void loop() {
// Turn off LED
digitalWrite(ledPin, LOW);

// Read analogue pin.
newHeartReading = analogRead(sensePin);
//Serial.println(newHeartReading);
//Calculate Delta
Delta = newHeartReading – lastHeartReading;
lastHeartReading = newHeartReading;

// Find new recent total
recentTotal = recentTotal – recentReadings[readingsIndex] + Delta;
// replace indexed recent value
recentReadings[readingsIndex] = Delta;
// increment index
readingsIndex = (readingsIndex + 1) % historySize;

//Debug
//Serial.println(recentTotal);

// Decide whether to start an LED Blink.
if (recentTotal >= totalThreshold) {
// Possible heartbeart, check time
if (millis() – lastHeartbeatTime >= debounceDelay) {
// Heartbeat
digitalWrite(ledPin, HIGH);
currentHeartrate = 60000 / (millis() – lastHeartbeatTime);
lastHeartbeatTime = millis();
// Print Results
//Serial.println(“Beat”);
if (currentHeartrate <= 200) { Serial.println(currentHeartrate); } } } delay(10); }

Processing code:

// Based on examples from Arduino’s Graphing Tutorial and OscP5 documentation
import processing.serial.*;
Serial myPort; // The serial port
int xPos = 1; // horizontal position of the graph
import oscP5.*;
import netP5.*;
OscP5 oscP5;
NetAddress myRemoteLocation;

void setup () {
// set the window size:
size(640, 480);
frameRate(25);
// Start OscP5
oscP5 = new OscP5(this,12000);

// List availabl serial ports.
println(Serial.list());

// Setup which serial port to use.
// This line might change for different computers.
myPort = new Serial(this, Serial.list()[0], 9600);

myPort.bufferUntil(‘\n’);
// Configure NetAddress to send OSC messages to
myRemoteLocation = new NetAddress(“127.0.0.1”,57120);
// set inital background:
background(0);
}

void draw () {
}

void serialEvent (Serial myPort) {
// read the string from the serial port.
String inString = myPort.readStringUntil(‘\n’);

if (inString != null) {
// trim off any whitespace:
inString = trim(inString);
// convert to an int
println(inString);
int currentHeartrate = int(inString);

if (currentHeartrate > 0) {
// Construct and send OSC message of the current heartrate
OscMessage myMessage = new OscMessage(“/heartbeat”);
myMessage.add(currentHeartrate);
oscP5.send(myMessage, myRemoteLocation);

// draw the Heartrate BPM Graph.
float heartrateHeight = map(currentHeartrate, 0, 200, 0, height);
stroke(127,34,255);
line(xPos, height, xPos, height – heartrateHeight);
// at the edge of the screen, go back to the beginning:
if (xPos >= width) {
xPos = 0;
background(0);
} else {
// increment the horizontal position:
xPos++;
}
}
}
}

/* incoming osc message are forwarded to the oscEvent method. */
void oscEvent(OscMessage theOscMessage) {
/* print the address pattern and the typetag of the received OscMessage */
print(“### received an osc message.”);
print(” addrpattern: “+theOscMessage.addrPattern());
println(” typetag: “+theOscMessage.typetag());
}

SuperCollider Code:

// create the OSCresponder
// Beeps each time it receives a heartbeat OSC message.
(
n = NetAddr.new(“127.0.0.1”, nil);
o = OSCresponder.new(n, “/heartbeat”, {
arg time, resp, msg;
msg.postln;
{ EnvGen.kr(Env.perc, 1.0, doneAction: 2) * SinOsc.ar([440,440], 0, 0.1) }.play;
} ).add;)

February 13, 2010. Uncategorized. Leave a comment.

LED Color Picker

LED COLOUR PICKER:
uses a color gradient to control the LED using colorpicker a color gradiant library. Colorpicker is easy to integrate with and allows you to receive color events in real-time, as you drag the mouse around the gradient.

This solution is written in Java and uses the same serial library (RXTX) as Arduino. it will run on any platform that Arduino supports (Windows/Mac/Linux etc.). RXTX libraries are included in the download so it will run on any of these platforms, out-of-the-box.

The application consists of Java application that serves as the colorpicker interface and an Arduino Sketch that receives RGB colors and applies them to the PWM pins

The basic process flow of the Java application is as follows:

– Open serial port to Arduino
– Initialize colorpicker component and register an event handler
– (In forever loop)
– Wait for colorpicker event.
– Send color to Arduino
– Wait for reply from Arduino (ACK)

The colorpicker runs in a separate thread and sends color events to the main thread.

The Java application sends the RGB colors in a sequence of four bytes: red, green, blue and a EOT byte. The EOT byte signals the end of a color sequence and instructs the Arduino to process the color. Since a byte has 256 values and we need all of them for the color values, I created a escape byte (0x2) to distinguish the EOT byte (0x1) from the color value (0x1). Any time a color value of 0x1 or 0x2 is sent, it is preceded by a escape byte and XOR’d with 0x20. When the Arduino receives the data via Serial.read(), it performs a corresponding XOR operation to un-escape the bytes.

Once the Arduino processes the color, it sends an ACK byte back to the Java application, so that it can send the next color. Without the ACK byte, we run the chance of overflowing the buffer by sending color events faster than the Arduino can process them.

Here’s the Arduino sketch:

// Adjust as necessary to match your RGB LED.  Remember to only use the PWM pins
int redPin = 11;
int greenPin = 10;
int bluePin = 9;

// Indicates what color we are reading next; 0 = red, 1 = green, 2 = blue
int pos = 0;

// red PWM value
int red = 0;
// green PWM value
int green = 0;
// blue PWM value
int blue = 0;

// indicates if next byte should be unescaped
boolean escape = false;

void setup() {
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);

Serial.begin(9600);

// turn on LED on low brightness
analogWrite(redPin,   16);
analogWrite(greenPin, 16);
analogWrite(bluePin,  16);
}

void loop () {

while (Serial.available()) {
int rgb = Serial.read();

if (rgb == 1) {
// end of RGB sequence byte
// reset pos
pos = 0;

// process this color
analogWrite(redPin, red);
analogWrite(greenPin, green);
analogWrite(bluePin, blue);

// Send ACK byte so Java app can send the next color
Serial.print(“k”);
Serial.flush();

// get next byte
continue;
} else if (rgb == 2) {
// escape byte
escape = true;
// discard byte and read next byte
continue;
}

if (escape) {
// unescape byte
rgb = 0x20 ^ rgb;
// reset escape
escape = false;
}

switch (pos++) {
case 0:
red = rgb;
break;
case 1:
green = rgb;
break;
case 2:
blue = rgb;
break;
}
}
}

To run the app, first download the project from my Google Code project. I’ve included the full Java source code and everything necessary to run the app, sans Java.

Next, connect your RGB LED to the Arduino PWM pins, as specified in the Arduino sketch. Be sure to use appropriate resistors so that you do not draw more current than the Arduino can supply. If you need a RGB LED, here’s a basic one offered by SparkFun . You could also use separate Red, Green and Blue LEDs and diffuse the colors with something like a paper box.

Now upload the sketch to your Arduino.

If you don’t have Java 1.5 or later, now would be a good time to get it. You can find out by opening a command prompt/shell and typing “java -version” If you see something like this then you are all set:

java version “1.5.0_16”
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_16-b06-284)
Java HotSpot(TM) Client VM (build 1.5.0_16-133, mixed mode, sharing)

Before running the Java application you need to open the run script for your platform and specify the COM port of your Arduino:

Windows: ledcolorpicker.cmd
Mac/Linux: ledcolorpicker.sh

The COM port should be the last argument on the line that starts with “java”

Now run the script for your platform:

Windows: double-click on ledcolorpicker.cmd (note: if the window closes immediately, open a command prompt and run the script again to get the error)

Mac/Linux: First you probably need to make it executable: “chmod u+x ledcolorpicker.sh”. Now run the script “./ledcolorpicker.sh”

The LedColorPicker application should now start up and be ready to go.

The Arduino processes colors in about 16ms — that is time it takes to send a color to the Arduino and receive an ACK @ 9600 baud. The Arduino can process color events almost as fast as the colorpicker can generate events. In this projects testing, only less than 2% of color events were discarded because the Arduino was busy processing a previous color. You could use a higher baud rate but with this level of performance it’s not necessary. This translates to the Arduino processing about 30 colors changes per second — not bad.

It is possible to make this solution wireless with minimal effort, using with XBee radios. Using the Arduino XBee Shield configured in transparent mode, you could put your LED across the room or anywhere within range and control it from your PC. In this configuration you would need two XBee radios, 1 Arduino XBee Shield and 1 USB-Serial device with XBee socket, such as the SparkFun’s XBee Explorer.

WATCH VIDEO!!!

This project is really interesting in that we could control light color so effectively in our project. It could be used to set the atmosphere in accordance to the imagery on screen.

food for thought!!!

February 12, 2010. Uncategorized. Leave a comment.

Laser Harp

What is a Laser Harp…?

Now with dual core Arduino’s…

The laser harp is a musical instrument made of light. A fan of beams shoots up from the floor into the night sky. The performer can create music by placing their hands in the beams. Not only does “breaking” the beam produce notes, but sliding the hand along the beam will also change the sound.

The harp does not produce any sound by itself, but creates MIDI data that can be connected to any modern synthesizer.

The laser harp concept was invented by Bernard Szajner and used extensively by Jean-Michel Jarre, and more recently Little Boots.

We need something to make  our project a little more interactive i feel. This laser harp really intrigued me and made me realise the effect of interactive sound. Getting the user more involved would bring our project to the next level. We were primarily ficussed on powerful imagery but i believe audio would really enhance the environment. Maybe the user cpuld control the imagery or audio themselves???

February 9, 2010. Uncategorized. Leave a comment.

Light Beat from Alex Beim on Vimeo.
How it Works:
Place your index finger on the sensor and see the light react to your heart beat.
Intellijel created the Heart Rate monitor sensor. No computers everything was running from an Arduino wirelessly connected to the Tangible Light Pixels inside the inflatables

1. Light Beat by Tangible interaction

By placing their hand on a sensor, the users heartbeat in used to create the beat of the light on a large inflatable balloon. The pulsing light is a representation of a persons heartbeat and displays what is otherwise a innately personal aspect of an individual From the website, “Intellijel created the Heart Rate monitor sensor. No computers everything was running from an Arduino wirelessly connected to the Tangible Light Pixels inside the inflatables.”

This Project really interested in that is uses the heart rate to control the light. I was thinking we could incorporate this type of idea into our project, be it controlling light sound or the imagery.

The imagery could pulsate, or the sound of the heart beat could create the atmosphere, there are many possibilities.

February 5, 2010. Uncategorized. Leave a comment.

Possibility1

ECG using a Sound Card
Medical signal processing on a PC

Published in issue 358, October 2006
ECG using a Sound Card
The heart monitor described here is the fruit of this work, and the software is available for free downloading.

February 3, 2010. Uncategorized. Leave a comment.