mental jib» Blog Archive » Beat Feet

Beat Feet– code incarnate

The code for Beat Feet is massive, and Eric did a great job of commenting the whole thing. Below is a zipped file ready for download. Or you can copy and paste the code below, but it won’t have tabs for classes.

Happy foot beating.

ZIP!

beat_feet

// Beat Feat

// Shoes that make sound.

// Yin Ho, Eric Mika, Arturo Vidich

// ITP Fall 2009

import processing.serial.*;

import controlP5.*;

import ddf.minim.*;

import arb.soundcipher.*;

import javax.swing.*;

Looper looper; // Handles cueing looped sequences in its own thread.

ControlP5 controlP5; // Sliders, buttons, etc.

Serial port; // Listen to the shoes.

Textlabel loopCount; // Keeps track of how many layers of loops we’re in.

PImage schematic; // The background UI. Designed specifically for my laptop @ 1440 x 900. Will need modification for other resolutions.

String[] states; // Stores MIDI instrument configurations.

ListBox stateList; // Present instrument configurations in the UI.

Textfield stateTextfield; // Set filenames

// Channel Monitors.

int channelCount = 8; // 4 sensor channels per foot.

ChannelMonitor[] monitors = new ChannelMonitor[channelCount];

WeightDot[] dots = new WeightDot[channelCount]; // Show distribution of weight across sensors.

// Synth Library

SoundCipher sc; // SoundCipher has been crashy… looking for alternatives.

int instrument = 0; // (0 – 127)

// Playback options. Currently supports WAV samples or Java Sound Synth samples. Pure MIDI is coming.

int SAMPLE = 0;

int SYNTH = 1;

// Choose one of the above to use.

int playMethod = SYNTH;

void setup() {

size(1440, 900); // Only looks right at this resolution.

background(0);

frameRate(60);

sc = new SoundCipher(this);

schematic = loadImage(“schematic.jpg”);

// println(Serial.list()); // Show serial ports.

String portName = Serial.list()[0]; // The XBee Explorer FTDI chip is usually first in the list.

port = new Serial(this, portName, 115200); // 115k bps, With 2 XBees transmitting ~30byte packets at 10ms intervals we need at least 96kbps.

// Set up the weight dots.

// Left Foot.

dots[0] = new WeightDot(511, 57);

dots[1] = new WeightDot(470, 135);

dots[2] = new WeightDot(541, 122);

dots[3] = new WeightDot(499, 325);

// Right foot.

dots[4] = new WeightDot(720, 57);

dots[5] = new WeightDot(755, 135);

dots[6] = new WeightDot(684, 122);

dots[7] = new WeightDot(707, 325);

// Set up the channel monitors.

controlP5 = new ControlP5(this);

String[] channelNames = {

“Left Toe”,

“Left Outside Ball”,

“Left Inside Ball”,

“Left Heel”,

“Right Toe”,

“Right Outside Ball”,

“Right Inside Ball”,

“Right Heel”,

};

// Place the channel monitors accross the bottom of the window.

for (int i = 0; i < channelCount; i++) {

int w = round(width / channelCount); // Set width based on screen width.

int h = round(height * .5); // Half the screen height.

int xPos = w * i;

int yPos = height – h – 1;

// Fix rounding errors for the last channel monitor’s width.

if (i == (channelCount – 1)) {

w = width – (w * (channelCount – 1)) – 1;

}

monitors[i] = new ChannelMonitor(channelNames[i], xPos, yPos, w, h);

}

// Set up the loop UI.

loopCount = new Textlabel(this,”x 1″,60,15,400,200,color(0, 255, 0),ControlP5.synt24);

loopCount.setLetterSpacing(2);

// Fill the state list box.

stateList = controlP5.addListBox(“stateList”, width – 250,115,210,120);

stateList.setColorForeground(color(0, 200, 0));

stateList.setColorBackground(color(0, 80, 0));

stateList.setColorActive(color(0, 200, 0));

stateList.setItemHeight(15);

stateList.setBarHeight(15);

stateList.captionLabel().style().marginTop = 3;

stateList.valueLabel().style().marginTop = 3; // the +/- sign

// Load states from a folder and populate the list box.

refreshStateList();

// Set up save state filename textfield.

stateTextfield = controlP5.addTextfield(“filename”,width – 250,70,100,20);

stateTextfield.setColorActive(color(255));

stateTextfield.setColorForeground(color(0, 200, 0));

stateTextfield.setColorBackground(color(0, 80, 0));

stateTextfield.setCaptionLabel(“”);

stateTextfield.setText(“File Name”);

// Set up save state button.

controlP5.addButton(“button”,1,width – 140, 70, 100,20);

controlP5.controller(“button”).setColorActive(color(0, 200, 0));

controlP5.controller(“button”).setColorBackground(color(0, 80, 0));

controlP5.controller(“button”).setCaptionLabel(“Save State”);

// Jump trigger UI.

// Time sets how long the performer has to be in the air before we call it a jump.

Slider jumpTriggerTimeSlider = controlP5.addSlider(“jumpTriggerTime”, 0, 500, 160, width – 250, 30, 100, 10);

jumpTriggerTimeSlider.setColorForeground(color(0, 200, 0));

jumpTriggerTimeSlider.setColorActive(color(0, 200, 0));

jumpTriggerTimeSlider.setColorBackground(color(0, 80, 0));

jumpTriggerTimeSlider.setLabel(“Jump Trigger Time”);

// Weight sets how close to 0s the sensors need to read before we consider him to be in the air.

// (This compensates for any residual readings even if the shoes are completely unweighted.)

Slider jumpWeightThresholdSlider = controlP5.addSlider(“jumpWeightThreshold”, 0, 500, 300, width – 250, 50, 100, 10);

jumpWeightThresholdSlider.setColorForeground(color(0, 200, 0));

jumpWeightThresholdSlider.setColorActive(color(0, 200, 0));

jumpWeightThresholdSlider.setColorBackground(color(0, 80, 0));

jumpWeightThresholdSlider.setLabel(“Jump Weight Threshold”);

// Pick the sound files.

String[] soundFiles = {

“hey.wav”,

“stuck.wav”,

“crash.wav”,

“bass.wav”,

“fape.wav”,

“tape.wav”,

“drill.wav”,

“earth1.wav”,

“jump.wav”,

};

// Create the looper object.

looper = new Looper(soundFiles, this);

smooth();

}

void draw() {

background(0);

// Draw the background image.

image(schematic, 0, 0);

noFill();

// Draw the Loop UI.

if (looper.recordingLoop) {

// Draw red circle if we’re recording a loop.

stroke(255, 0, 0);

ellipse(30, 30, 40, 40);

}

else {

// Draw green “play” triangle if we’re playing back a loop.

stroke(0, 255, 0);

triangle(10, 10, 10, 50, 40, 30);

if (looper.loops.length > 0) {

loopCount.setValue(“X ” + looper.loops.length);

loopCount.draw(this);

}

// Draw the channel monitors and weight dots.

for (int i = 0; i < channelCount; i++) {

monitors[i].draw();

dots[i].draw();

}

// Optionally press keys 0 – 8 to cue audio, useful for sound checks and debugging.

void keyPressed() {

// Go from ASCII to integer.

int numberKey = keyCode – 48;

// Do some bounds checking and play the sample.

if (numberKey >= 0 && numberKey < monitors.length) {

//println(“Playing sample ” + key);

int pitch = 0; // Always 0 for samples…

// If we’re using the synth, get sample info from the associated channel.

if (playMethod == SYNTH) {

pitch = monitors[numberKey].getPitch();

numberKey = monitors[numberKey].getInstrument(); // Look out! this changes numberKey, so we can’t use it for monitor indexing after this.

}

looper.playSample(numberKey, 0.0, 0.0, pitch, playMethod, false);

}

void keyReleased() {

if (key == ‘ ‘) {

// Space bar starts and stops looping for debugging and testing.

// Use keyReleased() instead of keyPressed() so it doesn’t get fired in quick succession.

if (!looper.recordingLoop) {

looper.startRecording();

}

else {

looper.stopRecording();

}

if ((key == DELETE) || (key == BACKSPACE)) {

// Remove all the loops.

looper.deleteLoops();

}

// =================================================================================

// Receive serial data form the shoes.

// Since the XBees are in API mode and there are no Arduinos involved, we need

// to parse the XBee packets to extract the sensor data.

// The packet structure is documented here: http://ftp1.digi.com/support/documentation/90000866_C.pdf

// This should really be a library or class.

// If the XBee Library worked, that would be a better alternative.

// ( http://www.faludi.com/code/xbee-api-library-for-processing/ )

// “Frame” and “Packet” are used inconsistently and interchangeably in variable names.

int byteCounter = 0;

int frameIndex = 99999;

int frameLength;

int msb;

int lsb;

int[] frameArray;

int framesReceived = 0;

void serialEvent(Serial port) {

// println(“Available: ” + port.available());

// Grab the bytes as they arrive.

int latestByte = port.read();

// If the frame index is bigger than length and we received a frame-start byte (126), then start a new packet frame.

if ((latestByte == 126) && (frameIndex > (frameLength + 3))) {

frameIndex = 0; // Start the frame.

// Parse the bytes if we have a whole frame.

if (framesReceived > 0) parseFrame(frameArray);

framesReceived++;

}

// Byte 1 is the Most Significant Byte (MSB) of the checksum.

if (frameIndex == 1) msb = latestByte;

// Byte 2 is the Least Significant Byte (LSB) of the checksum.

if (frameIndex == 2) {

lsb = latestByte;

// Use the MSB and LSB to calculate the length of the frame.

frameLength = (msb <<

+ lsb;

frameArray = new int[frameLength];

}

// Add incoming bytes to the frame array (once we know how long it is).

// Making sure we’ve received a bunch of frames first seems to prevent start-up crashes.

if (((frameIndex > 3) && (framesReceived > 30)) && ((frameIndex – 4) < frameLength) && ((frameIndex – 4) >= 0)) {

// print(” ” + (frameIndex – 4) + “/” + frameLength + ” “);

frameArray[frameIndex - 4] = latestByte;

}

// print(frameIndex + “:” + nfs(latestByte, 3) + ‘ ‘);

frameIndex++;

}

// Now let’s parse the XBee data packets…

int LEFT_SHOE = 16371; // 16 bit XBee ID for the left shoe.

int RIGHT_SHOE = 21258; // 16 bit XBee ID for the right shoe.

int HAT = 11880; // 16 bit XBee ID for the hat.

// Set up the hat buttons.

int lastHatButtonValue = 6;

int hatButtonValue = 0;

int lastHatPress = 0;

// Set up the shoes.

int shoeChannels = 4; // Channels per shoe.

int historyDepth = 2; // How many frames of analog data to keep for each channel. Useful for calculating sensor velocity.

// Set up jump detection. These values are tweaked at run-time via the UI.

int jumpStartTime = 0;

int jumpTriggerTime = 200;

boolean inAir = false;

int jumpWeightThreshold = 300;

int recordWeight = 0;

// Create an array to store the sensor data in an ugly 3 dimensional array.

// The structure is as follows:

// { Shoe data container

// { Left shoe

// { Channel 1