I apologize for the erroneous presentation. I have updated my slides so that (hopefully) all the information presented is accurate. Thanks – Faye

Click HERE to see the distance sensor in action!

Click HERE to see the servos in action!

Inspiration

I got the idea of making an interactive Halloween Toy due to preparing for Halloween these weeks. While taking a look of different kind of sensors we had learned, I popped up the idea of creating a spider which could knot web by interacting with the pressure sensor as its belly.

Material

Conductive yarn, Wera Tech Tex 100/2 BL Trial SH Undyed

Making a conductive pom-pom

The first step is a regular way of making pompom. I made two circle pompom maker with cardboard. Placed the two rings together,  wrapped thread around them. Then cut around the edges of the doughnut layer at a time. And firmly tie the thread together between the 2 pieces of cardboard.. Removed the cardboard, I got a conductive pompom composed of wool and conductive steel fibers.

Making a felted pompom pressure sensor

Once I have the pom pom, I washed it with hot water and soap to make it felt. I kept rubbing until it felts and dry off it with towel. While at the first time, it was not that tight and felted as it is right now. What I did is wash and dry the pompom again, it looked better after that. (Actually, you can also do it by putting it into a washing machine.)

Making a spider toy with the felted pompom

Then I started to build the body and legs of the spider. I used four pieces of pipe cleaners. I made a loop in the middle of one of the pipe cleaner, and twist the other three around middle of first pipe cleaner. Adjust them to look like legs. At last, glued eyes for the spider for a cute look.

When I got the pompom done, I connected the sensor with Arduino and my laptop that I could see it works well.

Here is the video of the sensor is working. The graph just showed the change of resistance by pressing it.

Testing Spidey Sense

Processing data visualization

By programming with processing, I’ve visualized the data with a variable spider web responding to the change of pressure. So when people press its belly, the size of web just changed according to the value of resistance.

Here is the video of the final sensor result.

Spidey Sense

WHAT

Passive capacitive sensors can be made out of just about anything that holds charge. Paper, for it’s versatility, lightness, strength, and accessibility, is a natural space to explore. A capacitive paper sensor consists only of a conductive substrate, sandwiched between layers of conventional paperpulp–in this case, cotton.

MATERIALS

The sheet is formed from interwoven layers of cotton paper pulp and .25” chopped graphite fibers. The fibers are highly conductive and form a reliable capacitive surface. A lead, either of stainless-steel thread or adhesive copper tape is embedded in the carbon, to allow for convenient connections.



Processes

Paper is usually made out of plant fibers. Most need to be extensively processed before use, but pre-processed pulps are widely available. A vat of conditioned cotton pulp is agitated, suspending the pulp in water. A mould and deckle–traditional paper-making supplies–is dipped in the water, forming a thin layer of woven fiber over a fine screen. Once the water is drained, the resulting sheet is ‘couched’ (rhymes with smooched), on an absorbent surface. The conductive layer is formed from .25″ carbon fibers, which when wet and agitated, interface with each other in a way very similar to paper. A conductive strand, either steel thread or adhesive copper, is sandwiched between the layers, completing the sensor.

To create multiple capacitive panels, I made a divided deckle, shown here after immersion in the carbon-fiber pulp.

Four conductive carbon-fiber panels.

Finally, a conductive lead was embedded within the carbon, to provide for easy hook-ups to circuits and other sensors. This step is not strictly necessary, and naturally, modifies the overall capacitance of the panel, but I thought it would be useful (and it was!)

Adhesive copper tape embedded in carbon fiber.

TESTING

The capacitors were used in a simple circuit, connected to an Arduino. The CapSense library generated a signal, and the response was observed visually in a Processing script. The capacitance of several sheets was measured independently, using specialized lab gear for the task. For active capacitance, it spat out the happy values for a 4 x 5.5” square sheet:

• Side-by-side, 6pF
• Face-to-face, 40pF

Passive capacitance was not independently measured, which just seemed trick, though the effects of the changing capacitance in a relaxation oscillator circuit was observed on an oscilliscope.

Carbon-Fiber Capacitive Sensor Presentation

Carbon-Fiber Capacitive Sensor Datasheet

110111 Oobleck Print

Presentation Notes/Talking Points:

MAS S62 Project 2 presentation notes

Since this is a pretty new area to me. I wanted to better understand different types of sensors. I experience with making a stretch sensor, a bend sensor and pressure sensors in lab. The idea of touching and sound gave me the inspiration to create something that allows people to communicate with each other through pressure sensors.

My inspiration came from games pieces such as magnetic poem pieces, Scrabble, and Banagram, all uses small game pieces with words to convey words or sentences. I also thought about how Morse Codes used a tapping sequence (sound) to communicate. I thought a combination of the two would be an interesting area to explore.

How to make a felt sensor

Materials used

• Two pieces of 2″x2″ felt pieces
• Two pieces of 1.5″x1.5″ velostat
• Conductive velcro
• Conductive thread
• Conductive tape
• Regular needles and thread

Instructions

How to create unique identity for individual sensor?

It was a challenge figuring out how to assign a “word” to a piece of sensor” through Arduino. I looked at three possibilities:

Testing

Felt Sensor Testing

As you can see from the video, the connection points need some improvements. This would achieve more stable visualizations. Also the visualizations looked more or less the same from the different felt pieces, thus my goal of providing a different output from each piece was not achieved.

Potential solutions:

• Construct sensors to provide unique voltages
• Create unique visualization on processing for each sensor
• Better construction of connection points

Future application for this experiment could be a sound pieces game for visually impaired or people with reading challenges.

Model Clay Sensor

I also had some extra time to create a pressure sensor made out of model clay.

The construction is more or less the same as the felt sensor, except I used conductive threads instead of tape. Below are the results:

View the testing of these sensors here.

These could have interesting applications in children’s crafts as an easy way for people to make sensors.

PPT

Sensor 1. Capacitor

Inspiration:

Inspired by our research topic from last week, in I decided to play with capacitors in order to further my knowledge of how they work.  The SmartSkin sensor desicribed in our paper is far more complex than this one I made this week. Though building this sensor I learned a great deal about how capacitors work and their relation ship with resistors.

Fabrication:

To create this sensor I used felt and a conductive piece of fabric with iron on sticky back paper.  I ironed on the conductive piece of fabric, cut with a lead to attach to the arduino.  After creating the sensor I had to  experiment with differnt types of resistors inorder to slow the discharge down and get  measuarble data.  In this process I learned about the color coding on resistors as well as why a hight resistance is necessary to make the capasitoy function well.  After testing several different sensors d a 100000 Ohm resistor was found to work well.

Computation:

I ended up using (with modifications) the arduino code Leah posted on the course website found here. I started by changing the pins to accommodated the lilyPad.  Inspired by the exercise we did in class with water, more complex systems like the Theremin, and other musical capacitors like it, I decided to play with sound. In processing, I began with the code provided for our in class exercise and modified it to play a series of sounds as your hand moves from in proximity to the sensor. One sound also changes in pitch depending on how close or far away from the sensor your hand is.

Application:

In conducting this experiment a variety of potentials interactive applications have been made apparent. The soft flexible nature and shape of the sensor makes it attractive to use in physical interfacing. It could be used to make interactive quilts, or prints on fabric. They can be used to make more complex wearable interactive musical instruments. Or like the smartSkin, possibly a bigger fabric sensor could be created using rows of transmitters and receivers to create a grid of capacitors.  This could be used to flexible, soft, and also beautiful surfaces. These surfaces could becomes systems that reveled different pieces of sound and or projection that are part of a larger narrative.

Sensor 2. Array of Fabric Pressure Sensors

Inspiration & Fabrication:

The second experiment I conducted was with fabric pressure sensors made of different materials. These sensors were created last semester during in Leah’s New Textiles class. More information about their construction and individual attributes can be found here .

Prior to this investigation I had created several different sensors but was only able to use one at a time. This week I my challenge was to create a system that could used data from more than one sensor at a time. Each sensor was initially hooked up to alligator clips for testing. After testing each sensor was sewn onto a larger piece of fabric. The lead for the arduino analog pin was sewn out of with conductive thread to the edge of the fabric. each are attached to the same conductive strip of fabric that runs to ground ground

Computation:

In order to collect data from all three sensors I used this code that hard wires each arduino pin for each sensor . In talking to Leah I learned that this can be done in an additional more abstract way allow the code to be more flexible and in turn easer to add or remove sensors from the array with out changing the code. The code I used is a modification of the code posted here.  Though processing, I was able to connect the sensors to a visual response.

Application:

This array of fabric resistive sensors had similar potentials to the capacitor.  The difference begin that using pressure sensors requires actual contact with the sensor to receive data.

Encountered Problems:

The capacitor data changes drastically depending on what is around it.  I notices that when using the sensor with one hand touching various other objects with the other hand changes the data output of the sensor significantly. This created a challenge when programing the sounds to respond to the data output.

Code:

Ardunio code for multiple sensors

Ardunio code for Capacitors

Processing Code for Array of Sensors:

import processing.serial.*;

Serial myPort; // The serial port

//variables for collecting and storing information

int ARRAYX = 2;

int ARRAYY = 2;

int [][] sensorArray = new int[ARRAYX][ARRAYY];

//variables for drawing information on the screen

int spacing = 100;

void setup () {

//set the window size:

size(800, 600);

// list all the available serial ports

println(Serial.list());

// open the appropriate port

myPort = new Serial(this, Serial.list()[0], 9600);

// don’t generate a serialEvent() until you get an exclamation mark character

myPort.bufferUntil(‘!’);

// set inital background:

background(#174D67);

}

void draw () {

background(#174D67);

//loop through the array

for (int i=0;i<ARRAYX;i++)

{

for (int j=0;j<ARRAYY;j++)

{

if (sensorArray[i][j] < 20) {

ellipse (200, 200, sensorArray[i][j], sensorArray[i][j]);

color (#ffffff);

noStroke();

smooth();

}

else {

if (sensorArray[i][j] > 21 && sensorArray[i][j] < 40) {

ellipse (300, 300, sensorArray[i][j], sensorArray[i][j]);

color (#ffffff);

noStroke();

smooth();

}

else {

if (sensorArray[i][j] > 41 && sensorArray[i][j] < 60) {

ellipse (400, 200, sensorArray[i][j], sensorArray[i][j]);

color (#ffffff);

noStroke();

smooth();

}

else {

if (sensorArray[i][j] > 61 && sensorArray[i][j] < 80) {

ellipse (500, 400, sensorArray[i][j], sensorArray[i][j]);

color (#ffffff);

noStroke();

smooth();

}

else {

if (sensorArray[i][j] > 81 && sensorArray[i][j] < 100) {

ellipse (600, 200, sensorArray[i][j], sensorArray[i][j]);

color (#ffffff);

noStroke();

smooth();

} else {

if (sensorArray[i][j] > 200 && sensorArray[i][j] < 300) {

ellipse (700, 300, sensorArray[i][j], sensorArray[i][j]);

color (#ffffff);

noStroke();

smooth();

}

}

}

}

}

}

}

}

}

void serialEvent (Serial myPort) {

//store a batch of data into variable “inString”

//batches are separated by exclamation mark characters

String inString = myPort.readStringUntil(‘!’);

//split the data into rows (rows separated by new line characters)

String[] incomingArrayRows = splitTokens(inString, “\n”);

//loop through all of the rows

for (int i=0;i<ARRAYX;i++)

{

//split each row into entries (entries separated by tab characters)

String[] incomingArrayEntries = splitTokens(incomingArrayRows[i], “\t”);

//loop through all of these entries

for (int j=0;j<ARRAYY;j++)

{

//store entries in the “sensorArray” variable

sensorArray[i][j]=int(incomingArrayEntries[j]);

//print the entries to the terminal, separated by tab characters

print(sensorArray[i][j]);

print(‘\t’);

}

//print a new line after each row

println();

}

//print a new line after each batch of data

println();

}

Processing Code for Cap Sensor:

import processing.serial.*;

import pitaru.sonia_v2_9.*;

Serial myPort; // The serial port

int xPos = 1; // horizontal position of the graph

Sample tone;

Sample tone2;

Sample tone3;

void setup () {

// set the window size:

size(400, 300);

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

Sonia.start(this);

// Create a new sample object.

tone = new Sample( “Tone1.wav” );

tone2 = new Sample(“Tone2.wav”);

tone3 = new Sample(“Tone3.wav”);

// Loop the sound forever

// (well, at least until stop() is called)

}

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);

if (inByte > 1 && inByte < 10 ) {

tone.repeat();

tone.setVolume(1);

smooth();

} else if(inByte > 10 && inByte < 40){

tone2.repeat();

tone2.setVolume(2);

smooth();

} else if(inByte > 40 && inByte < 70){

tone3.repeat();

tone3.setVolume(2);

smooth();

} else {

tone.stop();

tone2.stop();

tone3.stop();

}

//println (inByte);

// draw the line:

stroke(127, 34, 255);

line(xPos, height, xPos, height – inByte);

// change the playback speed using the incoming data

float ratio = (float) (inByte/height)*5;

//println(ratio);

tone.setRate(ratio*88200, 0);

println(inByte + ” “+ ratio*88200);

//tone.setVolume(ratio);

// at the edge of the screen, go back to the beginning:

if (xPos >= width) {

xPos = 0;

background(0);

}

else {

// increment the horizontal position:

xPos++;

}

}

}

// Pressing the mouse stops and starts the sound

void mousePressed() {

if (tone.isPlaying()) {

tone.stop(); // The sound can be stopped with the function stop().

}

else {

tone.repeat();

}

}

// Close the sound engine

public void stop() {

Sonia.stop();

super.stop();

}

The aim of my project is to create a high blood pressure sensor, such that at a certain ‘danger’ mark, an LED will light, and a buzzing sound will be produced. I thought of combining a couple of existing devices, in particular a mercury sphygmomanometer as well as a metal detector to create this new sensor.

In a mercury sphygmomanometer, mercury rises up a glass gauge according to the blood pressure measured on a patient’s arm. The idea is to attach a metal detector that functions as an alarm or a warning to a certain mercury mark. As the reading for hypertension is 160mmHg, the detector is attached here.

Here are the parts that I was working with:

On the bottom left is the board and the metal rod that will form the bulk of the metal detector, and moving to the left I have laid out the various capacitors, resistors and diodes. The bottom right is the solder, which will turn out to be the trickiest part of this project.

Here is the underside to the board pre-solder. For a neophyte like me, this is intensely intimidating!

And this is how it looks when it is done!

This is how the metal detector component looks when it is done. The little red dot is the LED light, and the round black tack next to it is the buzzer. The aluminum dial allows me to adjust the sensitivity of the metal detector.

Unfortunately, the metal detector doesn’t work, I am not sure exactly why. The instructions warn me that the most common problem is due to the circuit breaking or shorting from poor soldering, so that could be it.

But the idea is to attach this metal detector to the sphygmomanometer, like so:

Once again, my project was motivated by my curiosity to explore interesting and unfamiliar territory.  I decided to see if I could make my own capacitive sensor and then use it in a project of some sort.  After numerous fiascoes with Arduino and computers, I was able to get the capacitive sensor to work and then implemented it into a fishing game.  It was a highly frustrating but really fun project to do.

Circuitry

Right above is the circuit diagram for a simple capacitive sensor.  The human’s hand and a rectangular piece of conductive material form a capacitor.  The output the measures the time it takes for that capacitor to discharge.  The closer the hand and coductive material are together, the longer it takes to discharge.  Also, the higher the resistor between pins A & B, the more sensitive the sensor is.

The picture on the right shows the actual sensor I built.  The white alligator clips connect pins A and B together through a resistor.  The yellow aligator clip  is the output sensor connected to one half of the capacitor.  The black alligator clip is ground and is held by the human user.

The major problems I had with the sensor was the connections.  At first, I just wrapped the resistor through the actual holes in the Lilypad, but it was very wiggly and not secure at all.  The alligator clips work better but they tend to disconnect from the Lilypad, or touch each other when they are close, causing a short circuit.

I decided to use an Arduino Duemilanove because of its pin headers.  The last problem was connecting all the LEDs to ground. A short piece of black wire and a wirenut solved that problem.

Coding

My next big step was to modify the code.  Now that the sensor worked, I wanted to use it to light up LEDs.  There are three sets of code that had to be added to the capacitive sensor sample code that we were given.

This bit of code is put under the void setup() section (Serial.begin(9600) is already in the sample code).  Basically, it is naming pins 2-5 as output pins for my LEDs.  Pins are automatically inputs so you need to declare them as outputs.  You can have as little or as many as you want; I used four pins because I had four colours of LEDs.

This next bit of code is under the void setup() section (sensorValue=mysensor.capsense(30) is already in the sample code).  This is used to limit the numbers that the capacitive sensor was showing in the serial monitor, because of too much fluctuation.  So anything less than 100 becomes 0 and anything more than 1275 becomes 1275.

This last bit of code is also under the void setup() section.  It is pretty easy to understand, just very annoying to write up.  This is what controls which LEDs light up at which level of distance.

The first if;else phrase controls pin 2 (red LED).  When the sensor values (that have been simplified to (100-1275) read 500 or more, the red LED goes on.  If the value is less than 500, the red LED is off.

The second if;else phrase controls pin 3 (yellow LED).  When the sensor values read 200 or more, the yellow LED goes on.  If the value is less than 200, the yellow LED is off.

The next if;else phrase controls pin 4 (green LED).  When the sensor values read 150 or more, the green LED goes on.  If the value is less than 150, the green LED is off.

The last if;else phrase controls pin 5 (blue LED).  When the sensor values read 100 or more, the blue LED goes on.  If the value is less than 100, the blue LED is off.

In short, the LEDs light up in this order as you get closer: blue, green, yellow, red.

The moment each LED turns on can be changed by messing around with the sensorValues.  It all depends on how you want to use the sensor.

Fishing Game

Now that I had a capacitive sensor that controlled LEDs, I had to figure out something to do with it.  I decided to make a game (of course!)  The game is played on a board that looks like a lonely island at sea at night.  The “fish” is a piece of foil that is hidden within the “ocean” of the board.  The player has to use their finger to “sense” and find the fish in a visual Marco-Polo type game.

Future Applications

One of the projects that I really want to work on sometime is interactive wallpaper.  I explored that a little with my Aries star project for the conductive project assignment, but that required a touch switch.  Using a capacitive sensor feels better, more natural, and you don’t have to worry about touching the exact right spot.  This is something I really want to expand on in the future.  Capacitive sensing wallpaper.

Presentation: Fish Sensing

This project is essentially a research conducted as a precursor to the final project. I am planning on creating a modular smart system consisted of elastic material, sensors and actuations for the final project and due to the complexity and limited budget, digital simulation will play a big role during the design process. Thus, studying the feasible method of bridging the sensors with the digital representation in real-time simulation was the main objective of my sensor project.

Firefly is a tool created by Andy Payne and Jason Kelly Johnson in order to connect Grasshopper (a free plug-in for the popular CAD software, Rhino) with Arduino micro-controller. One of the greatest strength of this tool is the fact that it is integrated with 3D CAD software environment which enables simulating and visualizing complex 3 dimensional geometries.

A flex sensor and a photocell sensor were tested to see how effectively Firefly can bridge between the preliminary designed geometry and the micro-controller. The geometry was built using Grasshopper and Rhino, as a parametric/ generative model. The sensor data that flows into the Firefly components are converted using ReMap component and Smooth component in order to manipulate the parameters of the geometry.

Demonstration Video

Grasshopper/Firefly Definition

Parametric Geometry Visualization

Sensors, micro-controller set-up

Firefly menu bar and Definition

My reading concerns a project by Daniela Rosner and Kimiko Ryokai that attempts to weave something of the process of making a handcrafted object such as a knit into the fabric of the knit itself. More specifically, Rosner and Ryokai wants to weave the memories in the form of audio, visual as well as textual recordings into the pattern of the knit. In some ways, what Rosner and Ryokai has done is to see the knitted yarn as a linear temporal strand, a timeline upon which experiences can be embedded into.

The system setup

Called Spyn, the project employs a rotary encoder attached to the yarn basket, which tracks the amount of yarn being used. The yarn has been preprinted with dots of infrared ink spaced regularly apart. As the knitter knits, the rotary encoder tracks the number of dots pulled through per unit measure of yarn. The dots also provide a kind of trackable resolution onto the knitted surface. A IR enabled camera captures video, image and audio, which are stored in the core computing system attached to the rotary encoder. This system also stores data that is automatically collected, such as GPS.

How it performed

Each knitting session involved semi-structured interviews, a first-used trial in which the knitters familiarize themselves with the system, and a knitting session where the knitters make something. The users are also moved around from location to location to observe mobile knitting and collect location data points.

Some users collect data in a diaristic manner, using the sensors to record the lengthy knit process over a given length of time, using photographs. Another used Spyn to make connections between two disparate things, between baked cookies and a knitted scarf.

The data that is recorded onto the knit is accessed via a touchscreen, which displays a photographed image of the knit upon which points of data are highlighted. When the user touches these points with his/her finger, the specific recordings are brought up.

Additional Readings

Daniela K. Rosner. Mediated crafts: digital practices around creative handwork. CHI EA ’10 Proceedings of the 28th of the international conference extended abstracts on Human factors in computing systems. (http://bit.ly/sU67fK)

Daniela K. Rosner & Kimiko Ryokai. Reflections on craft: probing the creative process of everyday knitters. C&C ’09 Proceeding of the seventh ACM conference on Creativity and cognition. (http://bit.ly/sqjYpC)

Powerpoint and PDF links

PDF (http://www.flipdrive.com/file/211d251832cdf37171127fd7d001.pdf)

PPT (http://www.flipdrive.com/file/06a0830ceabc5b82a53fb3b3cdc.pptx)