Packaging and Printing (and more packaging)

Almost done!

The last  two weeks or so I’ve spent wondering what the next version of Thing might look like. Been sketching a bit and just collecting random thoughts and ideas. This week I went down to Godsbanen (for those of you in Aarhus go check it out, you can read more about it here), where they have a wood-shop with all the machinery that your heart desires. It’s brilliant and pretty cheap as well. And they’re pretty helpful too as I was taken on a grand tour of nearly all the different machines.

So, I went down there and bought some walnut wood as I love the brownish color and grain. Got some help cutting it up and then drilled a few holes I knew the size of. Whats new about this version is that instead of a diffuse red LED Ill be using a super-bright LED. The LED will have its own box so it can be positioned in various ways as a kind of projector. More on this later.  I’ll upload some sketches and more pictures in the coming week.

Finally dragged myself up to the lab today after a couple of days recovering from New Years Eve. Today (and yesterday) Ive been reading up on Albert Borgmann, or rather Daniel Fallman writing about Borgmann. Love that guy – both Borgmann and Fallman. Don’t know why I haven’t heard of them before.It was a coincidence I stumbled upon them as I was talking to a fellow student, Jonas, who has an office space here in the building where the lab is. He had written an exam on Borgmann which he sent to me (but I have yet to read).

Any Given Sunday

NOTE: This setup has been improved somewhat – look at the more recent posts above this one.

So in my experimental phase of this bachelor-project Ive been looking at different ways to gather input from the Arduino. As noted above I have, amongst others, been exploring the temperature and humidity sensor, the MQ 3 gas-sensor which can detect ethanol (alcohol to lay people), and last but not least the sending and receiving of infrared light, in an attempt to detect a persons heartbeat. Theres something fascinating about being able to register (and see/feel/hear) a persons heartbeat (Im still trying to figure out what to do with this input – that is, once I get it up and running!). As I’ve also described below in the post written in Danish, the IR heartbeat sensor works by sending infrared light from the IR-LED to a IR phototransistor. By placing the two beside each other and placing your finger on top of the two, the infrared light will travel from the IR-LED through your finger and into the IR phototransistor. It so happens that with every beat of your heart blood is pumped out into the veins of your body, and when that blood surge reaches your fingertip, the resistance is increased – and the infrared light has a harder time getting through. In this way a heartbeat can be detected by reading the amount of infrared light received by the IR-Transistor.

(Note: Fritzning is an awesome (and free) program you can use to visualize and share your Arduino projects, see http://fritzing.org)

Fritzing:

The Arduino code: (based on cmpercussion.blogspot.dk/2009/07/heartbeat-sensor.html)

// Pins
const int sensePin = 0;

// Hearbeat detect variables
int newHeartReading = 0;
void setup() {
// initialize the serial communication:
Serial.begin(9600);
// initialize the digital pin as an output:
}

void loop() {
newHeartReading = analogRead(sensePin);

delay(200); // Short delay for faster response to light.

// Read analogue pin and print
Serial.print("Input value is: ");
Serial.println(newHeartReading);

}

En oversigt og intro til Bachelor-bloggen

[Under Construction]

This project is fairly simple and extremely cheap. (Disclaimer: embarking on this project will require some effort). In the end you’ll hopefully have a heartbeat sensor that works by sending infrared light up, through your finger, and into a phototransistor that can measure the amount of light passing through. When your heart beats, blood is pumped from your heart out into your body. When blood fills your fingertip the infrared light has a harder time getting through to the phototransistor [for example, when there is less blood in your finger the amount of infrared light might read 800, the light passes easily through your finger, however, when blood enters the finger it blocks the infrared light from passing through resulting in a reading of 400]. What you’ll see when you read the input is small “spikes” in the readings indicating a heartbeat. What I’ve also done is Ive brought the data into Processing and visualized it (the Processing code can be found below). I’ve also attached an LED to the circuit allowing for the pulse to be outputted as light as well. The heartbeat input can be outputted in a variety of ways, including using a Piezo Speaker.

In a nutshell: Once you place your finger on top of the device, “connecting” the LED and IR-phototransistor, infrared light is sent through your finger and into the IR-phototransistor, which measures the amount of infrared light flowing through your finger. Once your heart beats it fills your fingertip with blood, making it harder for the infrared light to get through. This change can be seen by reading the Analog Input on the Arduino (which reads the IR-phototransistor). The data (numbers from 1-1000) can then be used to make an LED glow depending on the amount of infrared light flowing through.

For this project you will need the following materials:

1. An Arduino board (I’m using an Arduino Uno)
2. Arduino which can be downloaded here (it’s free)
3. Processing (also free!)
4. IR-LED like this one.
5. IR-Phototransistor like this one (theres both an emitter/IR-LED and a detector/phototransistor). There are a couple of different versions of this and as long as they have the same wavelength they will work fine (either 800 or 950nm, I think).
6. 2 x 3904n transistors
7. 5 x Resistors of varying resistance
8. 1 x LED (the ones that are “diffused” work best, like this one. It’s also possible to buy LEDs that are ‘superbright’, which instead allow light to pass through a narrow channel making for a much more focused light).
9. X amount of jumper wires

Fritzing

Arduino Code:

/* Based on
*
* Can you feel my heart beating?
* 
* james robert thompson
* 10/23/2010
*
* Rewritten by Rene Joehnke
*/

const int arrayLength = 90;
int arrayIndex = 0;
int array[arrayLength]; 
int arraySum = 0;
int arraySumOld = 0;
int sensorValueOld;

int pulse[arrayLength];
int pulseSum = 0;

int IRLed = 8;
int brightnessPin = 9;

int rangeLEDmin = 650;
int rangeLEDmax = 750;

// Define the number of samples to keep track of. The higher the number,
// the more the readings will be smoothed, but the slower the output will
// respond to the input. Using a constant rather than a normal variable lets
// use this value to determine the size of the readings array.
const int numReadings = 25;

int readings[numReadings]; // the readings from the analog input
int index = 0; // the index of the current reading
int total = 0; // the running total
int average = 0; // the average

int sensorValue = analogRead(A1);

// int inputPin = A0;

void setup() {
Serial.begin(9600);

for (int thisReading = 0; thisReading < numReadings; thisReading++)
readings[thisReading] = 0;

pinMode(IRLed, OUTPUT);
pinMode(5, OUTPUT);
}

void loop() {

digitalWrite(IRLed, HIGH);

// subtract the last reading:
total= total - readings[index]; 
// read from the sensor: 
readings[index] = analogRead(A1); 
// add the reading to the total:
total= total + readings[index]; 
// advance to the next position in the array: 
index = index + 1;

// if we're at the end of the array...
if (index >= numReadings) 
// ...wrap around to the beginning: 
index = 0;

// calculate the average:
average = total / numReadings;

average = map(average, 0, 1000, 1000, 0);

/*

**Extra setup: Connect an LED to digital pin 9**

Adjust the 2nd and 3rd variables to the lowest and highest analog output
you read when holding your finger on the device
The 0 and 255 maps the analog input to the brightness of the LED

*/

arraySumOld = arraySum;
//this is the sum of the last "arrayLength" sensor values.
arraySum -= array[arrayIndex];
array[arrayIndex] = average;
arraySum += array[arrayIndex];

pulseSum -= pulse[arrayIndex];
pulse[arrayIndex] = arraySum;
pulseSum += pulse[arrayIndex];

arrayIndex++;
if (arrayIndex > arrayLength-1) {

arrayIndex = 0;

}

Serial.println(average);

int sensorValueMapped = map(average, rangeLEDmin, rangeLEDmax, 0, 255);
analogWrite(brightnessPin, sensorValueMapped);

if (average > rangeLEDmax || average < rangeLEDmin ) {

analogWrite(brightnessPin, 5);

}

//Serial.println(sensorValueMapped);

// Extra setup END

delay(1);
}

Processing Code:

/*
Serial Graphing Sketch
by Tom Igoe
Language: Processing

This sketch takes ASCII values from the serial port 
at 9600 bps and graphs them.
The values should be comma-delimited, with a newline 
at the end of every set of values.
The expected range of the values is between 0 and 1023.

Created 20 April 2005
Updated 27 June 2008
*/

import processing.serial.*;

int maxNumberOfSensors = 6; // Arduino has 6 analog inputs, so I chose 6
boolean fontInitialized = false; // whether the font's been initialized
Serial myPort; // The serial port

float[] previousValue = new float[maxNumberOfSensors]; // array of previous values
float xpos = 0; // x position of the graph
PFont myFont; // font for writing text to the window

void setup () {
// set up the window to whatever size you want:
size(1400, 600); 
// List all the available serial ports:
println(Serial.list());
// I know that the first port in the serial list on my mac
// is always my Arduino or Wiring module, so I open Serial.list()[0].
// Open whatever port is the one you're using.
String portName = Serial.list()[0];
myPort = new Serial(this, portName, 9600);
myPort.clear();
// don't generate a serialEvent() until you get a newline (\n) byte:
myPort.bufferUntil('\n');
// create a font with the fourth font available to the system:
myFont = createFont(PFont.list()[3], 14);
textFont(myFont);
fontInitialized = true;
// set inital background:
background(0);
// turn on antialiasing:
smooth();
}

void draw () {
// nothing happens in the draw loop, 
// but it's needed to keep the program running
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, ","));

// print out the values
// print("length: " + incomingValues.length + " values.\t");
if (incomingValues.length <= maxNumberOfSensors && incomingValues.length > 0) {

for (int i = 0; i < incomingValues.length; i++) {

// map the incoming values (0 to 1008) to an appropriate
// graphing range (0 to window height/number of values):
float ypos = map(incomingValues[i], 900 , 500, 0, height);

// figure out the y position for this particular graph:
float graphBottom = i * height/incomingValues.length;
ypos = ypos + graphBottom;

// make a black block to erase the previous text:
noStroke();
fill(0);
rect(10, graphBottom+1, 110, 20);

// print the sensor numbers to the screen:
fill(255);
int textPos = int(graphBottom) + 14;
// sometimes serialEvent() can happen before setup() is done.
// so you need to make sure the font is initialized before
// you text():
if (fontInitialized) {
text("Sensor " + i + ":" + incomingValues[i], 10, textPos);
}

// change colors to draw the graph line:
stroke(255);
// stroke(150, 24, 24);
line(xpos, previousValue[i], xpos+1, ypos);
strokeWeight(1.5);

// save the current value to be the next time's previous value:
previousValue[i] = ypos;
}
}
// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(0);
} 
else {
xpos = xpos + 1.1;
}
}
}

Finally, after experimenting all day it happened. I found my pulse! It seems to have been there all along. After losing faith in the flimsy photo interrupter from yesterday I was at a loss as to what to do today, so I thought I might as well experiment a little. With my finger connecting the IR-LED and the Phototransistor I was getting readings around 120-130 (reading of the Analog 0 on the Arduino). I figured if I could get the IR-LED to shine brighter (or reversely the phototransistor to be more sensitive) I might get higher and more usable readings. Last week I remember having read about a product on the SparkFun website that let you optimize the amount of light emitting form the IR-LED. Here and here. It turns out the whole thing is actually just a transistor, an IR-LED and some resistors (all of which we had lying around the lab). I cleared the breadboard and put the new setup in place and voila, it worked (the short version of a longer struggle involving a few trial and error attempts).

But all is not well. The problem now is that it seems as if the sensor can only detect my pulse if I shine light directly through my finger – the IR-LED placed on one side and the IR-Transistor on the other. Update: It works!

More on all this tomorrow!

Fritzing for the new setup:

The Arduino Code: NB: Hover your mouse over the code and two icons will appear in the upper right hand corner that will let you copy the code

/* Based on
*
* Can you feel my heart beating?
*
* james robert thompson
* 10/23/2010
*
* Rewritten by Rene Jøhnke
*/

const int arrayLength = 90;
int arrayIndex = 0;
int array[arrayLength];
int arraySum = 0;
int arraySumOld = 0;
int sensorValueOld;

int pulse[arrayLength];
int pulseSum = 0;

int IRLed = 8;
int brightnessPin = 9;

void setup() {
Serial.begin(9600);
pinMode(IRLed, OUTPUT);
pinMode(5, OUTPUT);
}

void loop() {

digitalWrite(IRLed, HIGH);

int sensorValue = analogRead(A1);
sensorValue = map(sensorValue, 0, 1008, 1008, 0);
Serial.println(sensorValue);

// Extra setup: Connect an LED to digital pin 9
// Adjust the 830 and 860 variables to the lowest and highest analog output
// you read when holding your finger on the device
// The 0 and 255 maps the analog input to the brightness of the LED

int sensorValueMapped = map(sensorValue, 780, 880, 0, 255);
analogWrite(brightnessPin, sensorValueMapped);

// Stop the LED from blinking
/*
if(sensorValueMapped < 900) {
analogWrite(brightnessPin, 0);
} else {
analogWrite(brightnessPin, sensorValueMapped);
}
*/
// Extra setup END

arraySumOld = arraySum;
//this is the sum of the last "arrayLength" sensor values.
arraySum -= array[arrayIndex];
array[arrayIndex] = sensorValue;
arraySum += array[arrayIndex];

pulseSum -= pulse[arrayIndex];
pulse[arrayIndex] = arraySum;
pulseSum += pulse[arrayIndex];

arrayIndex++;
if (arrayIndex > arrayLength-1) {
arrayIndex = 0;

delay(5);
}
}

The Processing Code:

/*
Graph

The circuit:
Any analog input sensor is attached to analog in pin 0.

created 2006
by David A. Mellis
modified 9 Apr 2012

by Tom Igoe and Scott Fitzgerald

This example code is in the public domain.

www.arduino.cc/en/Tutorial/Graph

*/

import processing.serial.*;

Serial myPort; // The serial port

void setup () {
// set the window size:
size(1500, 700);

// List all the available serial ports
println(Serial.list());
// I know that the first port in the serial list on my mac
// is always my Arduino, so I open Serial.list()[0].
// Open whatever port is the one you're using.
myPort = new Serial(this, Serial.list()[0], 9600);
// don't generate a serialEvent() unless you get a newline character:
myPort.bufferUntil('\n');
// set inital background:
background(0);
}
void draw () {
// everything happens in the serialEvent()
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

if (inString != null) {
// trim off any whitespace:
inString = trim(inString);
// convert to an int and map to the screen height:
float inByte = float(inString);
inByte = map(inByte, 0, 1023, 0, height);

// draw the line:
stroke(216, 24, 24);
line(xPos, height, xPos, height - inByte);

// at the edge of the screen, go back to the beginning:
if (xPos >= width) {
xPos = 0;
background(0);
}
else {
// increment the horizontal position:
xPos++;
}
}
}

Next up:

1. Stabilize and optimize the pulse readings (see 4)
2. Research galvanic skin response
3. Make a more reliable setup (ie. solder the whole thing together)
4. Look at Op Amps to optimize the phototransistor (as I did the IR-LED).

UPDATE: A better pulse!