I wanted to make a presaure sensors that would give a smooth data to the computer. First I used two kinds of the resistive thread and knited with them on the small knitting mashine. The effect was very good, I was surprised how fast and easy it was to make a sensor. The resistance changed according to strech of the knitted piece. I started to work on a second sensor to compare the effects from difefrent materials. For the second pressure sensor I used felted wool mixed with aluminium yarn and resistive thread. The sensor gives “jumping” data and it is very hard to press, felt become very thick, I used two metal hooks to make a contact points for alighator clips. My last experiment was to use a conductive in and paint. I dyed a two pieces of sponge one using a coper paint mixed with violet dying paint, second with a conductive ink (carbon based). The coper paint was giving much better results at the beginning, but over night it lost some of it’s properties. I sewed in some small pieces of conductive thread to gain a better conductivity, but after my modification the sensor started to work like a on/offswitch. I’ve realized that the sponge had a better conductivity when it was still wet. I put some watter on my dry sensor and it gave some interesting resutlts – according to my graph it looked like  aline on the middle of my screen which means that the data should be exactly in the middle of 1023 range.

Arduino:

void setup() {

// initialize the serial communication:

Serial.begin(9600);

digitalWrite(A0,HIGH);

//  digitalWrite(A1,HIGH);

}

void loop() {

// send the value of analog input 0:

Serial.println(analogRead(A0));

// wait a bit for the analog-to-digital converter

to stabilize after the last reading:

delay(50);

//Serial.println(analogRead(A1));

delay(10);

}

Processing :

import processing.serial.*;Serial myPort;        // The serial portfloat weight = .05;
int xPos = 20; // horizontal position of the graphint lastX, lastY;void setup () {
// set the window size:  size(800, 600);   //smooth the graphics    smooth();  lastX = xPos;  background(0);  // 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:    }  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);

noStroke();
fill(#FFA500,inByte-10);    ellipseMode(CENTER);    ellipse(xPos,inByte, 20, 20 );

fill(#3366FF,inByte-10);    ellipseMode(CENTER);    ellipse(xPos,height-inByte–, 20, 20 );
stroke(#FFA500,inByte-10);  strokeWeight(.5);  line(0, 300,xPos,inByte-10);  weight = .15;
stroke(#3366FF,inByte-10);  strokeWeight(.5);  line(0, 300,xPos,height-inByte+10);  weight = .15;
}

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

Demo videos:

01 Strech Sensor

02 Pressure Sensor

Prototypes

Prior to creating the sensor, I had several prototypes.

General Technique Description: Each prototype is composed of knitted swatches that include conductive thread. With a darning needle, I sewed strips of highly conductive thread along two edges. The two edges were then connected to A0 and A1 ports of the Lilypad Arduino. The A0 and A1 corresponded to measuring the resistances along the y and x axes, respectively.

Sensor 1: I handknitted sensor 1. Initial testing of this sensor showed that the resistance in the y direction (direction of knit) had small-almost-non-detectable changes while the resistance in the x direction (knitted rows) had somewhat larger changes, but not enough to reliably detect which side the finger glove was on.

Sensors 2 -3: So, I created larger sensors ( 2 and 3 ) with the knitting machine at a smaller guage. Sensor 3 measured approximately 3″ x 4″.  Initial test of this sensor showed more changes in resistance, but, before completely testing this sensor thoroughly for possible implications of fabrication — I made a another bigger sensor.

Sensor 4: This sensor measured approximately 6″x6″. At the time that I made this sensor, I could better detect the changes in resistance in x and y directions.

Problems: To detect the changes in resistance in the x and y directions, I initially kept creating larger sensors. In testing sensors 3-4, however, I realized that my fabrication method was creating additional problems. The combination of knitting non-conductive with conductive thread resulted in a partial display of the conductive thread. This discontinuity would result in inaccurate measurements (i.e. lower resistance would be read in areas distant from the axis because more conductive thread was showing and vice versa).This discontinuity can be better seen in sensors 1-3.

Superman Sensor:

So, I decided to create another sensor that had a more uniform conductive-thread fabrication. Using a knitting machine, I knitted conductive thread which I then (attempted) to uniformly stretch over felt fabric.

This sensor, however, still had problems. This may again be due to imperfections in the fabrication such as discontinuity in the knitting, the uneven contact with the conductive fabric, and non-smooth felt fabric surface.  However, through this sensor, I was able to build more code in arduino and processing for detecting the x and y coordinates. See YouTube video

Arduino Code:

void setup() {
// initialize the serial communication:
Serial.begin(9600);
analogReference(INTERNAL);
digitalWrite(A0, HIGH);
digitalWrite(A1, HIGH);
}

void loop() {
// send the value of analog input 0:
Serial.print(analogRead(A0)); //Y-axis
Serial.print(“\t”);
Serial.println(analogRead(A1)); //x-axis
// wait a bit for the analog-to-digital converter
// to stabilize after the last reading:
delay(10);

}

Processing Code:

// Graphing sketch

// This program takes ASCII-encoded strings
// from the serial port at 9600 baud and graphs them. It expects values in the
// range 0 to 1023, followed by a newline, or newline and carriage return

// Created 20 Apr 2005
// Updated 18 Jan 2008
// by Tom Igoe
// This example code is in the public domain.

PImage front, back, superman, superman2, superman3;

import processing.serial.*;

Serial myPort;        // The serial port
int xPos = 1;         // horizontal position of the graph
float oldinByte = 0;  // previous inByte value
float inByteX = 0;
float newinByteX = 0;
float origInByteX = 0; // intial inByte value before mapping/scaling

float inByteY = 0;   //inital x position for plotting
float newinByteY = 0;   //inital x position for plotting
float origInByteY = 0; // intial inByte value before mapping/scaling

//for AVERAGING
int numReadings = 15;
int index = 0;                  // the index of the current reading

float[] readingsX = new float[numReadings];      // the readings from the analog input
float totalX = 0;                  // the running total
float averageX = 0;                // the average

float[] readingsY = new float[numReadings];      // the readings from the analog input
float totalY = 0;                  // the running total
float averageY = 0;                // the average

void setup () {
// set the window size:
size(600, 600);
back = loadImage(“supercity-background.jpg”);  // Load an image into the program
superman3 = loadImage(“superman3.gif”);

// List all the available serial ports
println(Serial.list());
myPort = new Serial(this, Serial.list()[0], 9600);
myPort.bufferUntil(‘\n’);   // don’t generate a serialEvent() unless you get a newline character:
background(0); // set inital background:

}

void draw () {
// everything happens in the serialEvent()

}

void serialEvent (Serial myPort) {

translate(0, 600);
// get the ASCII string:
String inStringY = myPort.readStringUntil(‘\t’);
String inStringX = myPort.readStringUntil(‘\n’);

if (inStringY != null) {
inStringX = trim(inStringX);
inStringY = trim(inStringY);

inByteX = float(inStringX);  //set inbyte value from reading
inByteY = float(inStringY);  //set inbyte value from reading
origInByteX = inByteX;
origInByteY = inByteY;

String inByteValX = “” + inByteX;
String inByteValY = “” + inByteY;

//Test to make sure I’m getting both values from A0 and A1
print(“  ” + inByteValX);
print(“  ” + inByteValY);
print(“\n”);

/********** remap X & Y values ***************/
inByteX = map(inByteX, 0, 1023, 0, width); //x position
inByteY = map(inByteY, 0, 1023, 0, height); //y position

//highest x value seems to be about 50
//lowest x value seems to be about  20
//neded to map between these values
if(inByteX > 50) {
inByteX = 50;
}
if (inByteX < 20) {
inByteX = 20;
}
newinByteX = round(map(inByteX, 20,50, 0, width)); //x position for plotting

//highest y value seems to be about 80
//lowest y value seems to be about 20
//neded to map between these values
if(inByteY > 80) {
inByteY = 80;
}
if (inByteY < 20) {
inByteY = 20;
}
newinByteY = map(inByteY, 20,80, 0, height); //x position for plotting
//newinByteY = -newinByteY; //make negative for graphing purposes
newinByteY = round(newinByteY*-1);

//Test to make sure I’m getting both values from A0 and A1
/*String inByteValX = “” + inByteX + “  (“+newinByteX +”)  “;
String inByteValY = “” + inByteY  + “  (“+newinByteY +”)  “;
print(“  ” + inByteValX);
print(“  ” + inByteValY);
print(“\n”);*/

/*************/
//take the average of prevoius 10
//output position

// VARIABLES:
//  newinByteX, newinByteY
//  readingsX[numReadings], totalX , averageX
//  readingsY[numReadings], totalY , averageY

//store values into an array
readingsX[index] = newinByteX;
readingsY[index] = newinByteY;

totalX = totalX + readingsX[index];  //calculate totals X
totalY = totalY + readingsY[index];  //calculate totals Y

index = index + 1;

//when reach 10, DO
if (index >= numReadings) {

averageX = totalX / numReadings;
averageY = totalY / numReadings;

String testX = “” + averageX;
String testY = “” + averageY;

print(“  index set to 0″);
print(“     “+testX+” “+testY + “\n”);

index = 0;
totalX = 0;
totalY = 0;
}
/*************/

String inByteVals = “    “+averageX+”, “+averageY;
text(inByteVals, averageX, averageY);  //show x & y value value
stroke(0,0,0);
text(inByteVals, averageX, averageY); //erase text

image(superman3, averageX, averageY);
text(inByteVals, averageX, averageY);

delay(10);
//background(0);
image(back, 0, 0);

}
}

I propose building an automated desktop device which is capable of simultaneously measuring a yarn’s changes in tension and resistance in response to stretch. Because it is computer-controlled, the device will also be able to determine the consistency of these measurements as well as the effects of cyclic loading and fatigue. Armed with the data collected by this machine, I’d like to be able to design the properties of braided yarns created using the Interweave CNC Braiding Machine based on the measured properties of its constituents.

finalproposal

Knit Stretch Sensor- This sensor was produced on the knitting machine using a conductive and non conductive yarn. When stretched taut, the conductive material aligns to produce a lower level of resistance.

Felted Pressure Sensor-

This sensor was produced by first combing together  natural and conductive roving. The blend was then felted together and shaped into a soft round pad that could be squeezed or pressed into with ones fingers. I also sewed a round felt pocket with openings on both sides. This serves as a protective shell for the padding, as well as provides an area for the alligator clips (that run to the Arduino) to connect to.

Here is an image of the felt padding being slipped into the protective pocket

Once inserted, alligator clips are attached to opposite ends of the pocket “mouth”, making contact with the conductive padding. Pressing the sensor reduces resistance that can be read on screen via Processing.

Bend Sensor-

This sensor was produced by inserting 2 layers of Velostat into a felt pocket that was then sewn closed. Velostat is a material that decreases in resistance when pressed or bent.

Bending the sensor…

Below are videos of the visual information produced when physically interacting with the sensors…

Arduino Code

void setup() {

// initialize the serial communication:  Serial.begin(9600);  digitalWrite (A0, HIGH);}
void loop() {

// send the value of analog input 0:  Serial.println(analogRead(A0));

// wait a bit for the analog-to-digital converter   // to stabilize after the last reading:  delay(100);}

Processing Code for this Example (you must copy and past this into your Processing sketch)

/* Processing code for this example

// Graphing sketch

// This program takes ASCII-encoded strings

// from the serial port at 9600 baud and graphs them. It expects values in the

// range 0 to 1023, followed by a newline, or newline and carriage return

// Created 20 Apr 2005

// Updated 18 Jan 2008

// by Tom Igoe

// This example code is in the public domain.

import processing.serial.*;

Serial myPort;        // The serial port

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

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

}

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(127,34,255);

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

}

}

}

*/

For this project I made a crocet pressure sensor with wool yarns and conductive (for sensor) yarns. Since I had no experience of crochet, this is a very interesting experience of learning this traditional technique. I added 1 stitch and 2 stitches alternatively to each of the stitches of the previous circle in order to create a flat piece. Then I used boiling water to bathe it and washed it with soap repeatedly. After around 6 rounds, it looked felted.
The result was good, though it seemed less sensitive to pressure after felting. I have to press it ver hardly.

I connected the textile sensor to the computer, using a very simple Arduino. I have no experience on programming language but I am always interested in the potential of processing for interaction and art. So I think this is a good opportunity for me to explore the processing, though it is very challenging for me. It is really hard and I spent long time on it, but it worth it to learn a new interesting thing.

The Bubble:
I firstly wrote some circles changing their locations and size based on the input from the sensor. Once I pressed the sensor, the circles got higher and smaller.
They looked like bubbles, which inspired me to write an interacrtion game responsive to people’s movements.

Catch the fish!-interactive game:
For the next step, I tried to create a game. A fish swims in the water, and you press the sensor to control the bubble to catch the fish. Once the bubble catch the fish, it changes color.
The difficult part of this game is to delete the trace of the fish while leaving the trace of the bubbles. I have tried two ways:
For the first method, I draw a blue square after the fish, which will delete the fish’s trace. It works smoothly. But there are still some traces above and under the fish (which look OK). And further, the blue square will delete some parts of the bubble as well.

For the second method, I firstly draw the fish and the bubble, and then refill the background every time after drawing. And then I re-draw the bubble. So the fish won’t leave any trace any more. I use Arraylist to remember the previous position of the bubbles. The problem of this program is the screen keeps flashing and it seems not very stable. I don’t know why.

Ink and wash painting- interactive abstract painting-in memory of Wu Guanzhong:

The processing visualizations always remind me the abstract art. I want to do some interactive art between people’s movement and the abstract painting. I get the inspiration from Wu Guanzhong, who is a famous abstract ink and wash painter. I think the essence of in and wash painting is “the amount of water added in ink” and the “white space in between”. Currently I cannot write too complicated processing. I tried “ink dots” with different transparency that randomly dispersed on the white “paper”. I used Agent to draw the random dots. Once I squeeze the sensor, the dots get bigger.

The process of drawing an abstract ink and wash painting:

THE VIDEO LINKS for this project:
The basic bubble
wTXJsA9hRW0
J0chHqeTypc

THE CODES OD PROCESSING:
1. BubblefishA(blue square):
import processing.serial.*;
// serial is an input from other computer

Serial myPort;
int xPos;
int xPos2;
PImage fishlazy;
PImage fishshock;
Boolean w = false;

void setup() {
size(800,600);
println (Serial.list());
myPort = new Serial(this, Serial.list()[2],9600);
myPort.bufferUntil(‘\n’);
background(0,0,255);
xPos = 0;
xPos2 = 1;
}

void serialEvent (Serial machine) {
String inString = myPort.readStringUntil(‘\n’);
if ( inString != null) {
inString = trim(inString);
float inByte = float(inString);
println (inByte);
inByte = map(inByte,0,1023,0,height);
xPos = xPos + 1;
xPos++;
xPos2 = xPos2 + 1;
xPos2++;
// when xPos >= width, renew
if (xPos2 >= width) {
xPos = 0;
xPos2 = 1;
background(0,0,255);
}
if(inByte*0.9=300) {
fishlazy = loadImage(“fishlazy.gif”);
image(fishlazy,xPos2,300,100,80);
fill(0,0,255);
noStroke();
rect(xPos2,300,2,80);
}
strokeWeight(map(inByte,0,1023,1,5));
noFill();
stroke(255);
ellipse(xPos,inByte*0.9,map(inByte,1023,0,100,10),map(inByte,0,1023,10,100));
//point(xPos, map(inByte,1023,0,height/1.5,100));
//line(xPos,height, xPos, map(inByte,1023,0,height,0));
}
}
void draw() {
}
void keyPressed() {
if ( key == ‘s’) {
w = true;
}

if ( key == ‘r’) {
w = false;
}

if ( key == ‘c’) {
saveFrame (“captureframe-####.jpg”);
}
}

2. BubblefishB(redraw the bubble):
import processing.serial.*;
// serial is an input from other computer

Serial myPort;
int xPos;
int yPos;
int r;
ArrayList bubblex;
ArrayList bubbley;
ArrayList bubbler;
PImage fishlazy;
PImage fishshock;
int fishx;
int fishy;
int fishdelay;
Boolean w = false;

void setup() {
size(800,600);
background(0,0,255);
xPos = 0;
fishlazy = loadImage(“fishlazy.gif”);
fishshock = loadImage(“fishshock.gif”);
fishx = 0;
fishy = height/2;
fishdelay = 10;

println (Serial.list());
myPort = new Serial(this, Serial.list()[2],9600);
myPort.bufferUntil(‘\n’);
}
//void draw() {
void serialEvent (Serial machine) {
String inString = myPort.readStringUntil(‘\n’);
if ( inString != null) {
inString = trim(inString);
float inByte = float(inString);
println (inByte);
// float inByte = random(0,1023);
inByte = int(map(inByte,0,1023,0,height));

if ((xPos > width)||(xPos == 0)) {
bubblex = new ArrayList();
bubbley = new ArrayList();
bubbler = new ArrayList();
xPos = 0;
}
background(0,0,255);
smooth();
frameRate(15);
//bubble
yPos = int(inByte*0.9);
r = int(map(inByte,1023,0,100,10));
bubblex.add(xPos);
bubbley.add(yPos);
bubbler.add(r);

for (int i = 0; i < bubblex.size(); i++) {
stroke(255);
//strokeWeight(map(inByte,0,1023,1,5));
noFill();
int tempx =(Integer)bubblex.get(i);
int tempy =(Integer)bubbley.get(i);
int tempr =(Integer)bubbler.get(i);
ellipse(tempx,tempy,tempr,tempr);
}

//fish
if (fishdelay == 10) {
image(fishlazy, fishx, fishy,100,80);
}
if (fishdelay < 10) {
image(fishshock,fishx, fishy,100,80);
fishdelay–;
}
if ((abs(xPos – fishx)<10) && (abs(yPos – fishy)< 10)) {
fishdelay–;
}
if (fishdelay == 0) {
fishdelay = 10;
fishx = 0;
}
if (fishx == width) {
fishx = 0;
}
xPos = xPos + 1;
fishx++;
}
}

void draw() {
}
void keyPressed() {
if ( key == 's') {
w = true;
}

if ( key == 'r') {
w = false;
}

if ( key == 'c') {
saveFrame ("captureframe-####.jpg");
}
}

3. The ink and wash painting:
import toxi.geom.*;
import processing.serial.*;
// here i import two libraries and declare machine// arraylist is like a package which consist of several items. its name is agents
// boolean is like a switch, i use it to stop and restart the script
Serial machine;
//Arraylist is like int. A An ArrayList stores a variable number of objects. This is similar to making an array of objects, but with an ArrayList, items can be easily added and removed from the ArrayList and it is resized dynamically.
ArrayList agents;
//Boolean judges two values (like a switch), true or false. here "true" is "turning off".
Boolean w = false;

void setup() {
size(600,600);
background(255,255,255);
// population means the number of generators, here i put 100 generators randomly (x ,y) in the windows
// x y is the location, it is random, sw is its opacity( black to white)
// agent. add means i put the item ( x,y,sw) into a bag called agents
// new Agent(x,y,sw) means the name of the item i call it Agent
// agents is the bag, each item inside called Agent, inside Agent there are x,y,sw int population = 100;
int population = 100;
//Arraylist name = new Arraylist. "new" means start/establish
agents = new ArrayList();
//for(condition){result} is a kind of circulation. (…)circulation. i only be used to run the program 100 times.
for (int i = 0; i < population; i++) {
int x = int( random(0, width));
int y = int(random(0, height));
int sw = int ( random(1,255));
agents.add(new Agent(x,y,sw));
}
machine = new Serial(this, Serial.list()[2],9600);
machine.bufferUntil('\n');

}

void draw() {
}

void serialEvent (Serial machine) {
String inString = machine.readStringUntil('\n');
if(inString != null) {
inString = trim(inString);
float inByte = float(inString);
println(inByte);
// here i try to draw now
//w is the switch, when it is false, we draw
// i recall the items in the bag and ask each of them to perform several actions
// 10 is the number which u can change.
//w controls "pause" of draw
if (w == false) {
//Arraylist.size() can read how many agents are there in the arraylist.
//Agent describes the properties of a
//Arraylist.get(i) means taking the sample No.i from the population
//name the selected sample as a
for ( int i = 0; i < agents.size(); i++) {
Agent a = (Agent) agents.get(i);
a.move(inByte);
a.drawdot();
if (inByte <= 900) {
a.drawcircle(inByte);
}
}
}
}
}

// here is about the item(Agent) inside the bag agents.
//class
class Agent {
//declare for the items inside
int xPos;
int yPos;
int sw;
//constructor. Agent(3 properties). Arraylist (named agents) contains 100 Agents.
//blabla=_blabla
Agent(int _xPos, int _yPos, int _sw) {
xPos = _xPos;
yPos = _yPos;
sw = _sw;
}
//behavior, action of each Agent//now it will move. acc is the coefficient linked to inByte scaled to -10 to 10//Vec3D is the distance, at last i add the distance to the position of the Agent
void move(float inByte) {
int acc = int(map(inByte,0,1023,-10,10));
//the Agent moves around the original position.
Vec3D vel = new Vec3D(random(-1,1)*acc,random(-1,1)*acc,0);
yPos = yPos + int(vel.y);
xPos = xPos + int(vel.x);
}
//draw the new position. stroke color is sw, u can change the number
void drawdot() {
stroke(sw);
strokeWeight(2);
point (xPos,yPos);
}
// draw the circle. change the color and the size as u want!
void drawcircle(float inByte) {
float r = map(inByte,0,1023,10,30);
fill (0, int(random(20,200)),0,10);
noStroke();
ellipse(xPos, yPos, r,r);
}
}
// here is the interface, s is stop, r is restart, c is capture frame
void keyPressed() {
if ( key == 's') {
w = true;
}

if ( key == 'r') {
w = false;
}

if ( key == 'c') {
saveFrame ("captureframe-####.jpg");
}
}

Thanks Leah and Ringo a lot for your help!

Hot Pink Hand Textile Sensor played to “Raise Your Glass” by the Glee Cast

Hot Pink Hand Textile Sensor - Watch the Video Above

To understand how the textiles work and interface with Arduino and Processing, I started by constructing the simple sticktape sensor that Hannah describes on her amazing website, “How to Get What You Want.”

Sticky Tape Sensor

See sticky tape demo video

From that initial prototype, I wanted to construct a more elaborate sensor that could intersect with something very tactile and natural to humans.  Hands came first to mind so I decided to start with my own hand as a frame for my project.

Cutting Out My Hand - It was like Thanksgiving!

I then sewed some conductive thread onto the leather hand to provide the underpinnings for the sensor.

I then tested multiple materials like the Velostat in different thicknesses with the Arduino and Processing software to understand which combinations of materials would be the most appropriately sensitive for hand touch.   I eventually defaulted to two layers of Velostat for the thumb and a layer of black rubbery material (not sure which one) for the palm.  It was then I realized that the hand needed some pizzaz so I cut some hot pink neoprene touchpoints that I could place on the hand itself which would be perfect for fingers.

As I tapped away and saw how tapping on the sensor felt like playing a piano, I decided to tap in sync to some music.

All in all, a very fun and rewarding project!

Process: I created several stretch and pressure sensors for this project. Each was constructed differently from different materials and as a result have a range of sensitivities and uses. I started by using the  conductive yarn I spun by hand and crocheting it into a strip. The yarn is resistant because of its mixture of aluminum and wool fibers.  The next sensor I created in a similar fashion by crocheting a cotton yarn with a conductive yarn with a higher resistance.  For both of these sensors, changes in resistance are created and measured by stretching the structure bring the resistance down.  After completing the two stretch sensors I started to experiment with needle felting. I started by creating a felt that in the center was a combination of aluminum fibers and wool.  This functions similarly to the stretch sensor made from the hand spun yarn. As the sensor is pressed the resistance drops. Pressure sensor two is constructed out of conductive yarn and traditional yarn to create a higher resistance. This is similar the the sensors Heidi and I built for our cell phone pouches.  The yarn was crocheted together in a circle. The last sensor I fabricated, inspired by Hannah’s bend sensors,  is the most complex.  Here I used two pieced of felt (one created by hand), conductive thread, very small pieces of conductive thread, and velostat to create the sensor.  Here conductive thread is sewn into each half of the sensor attaching to a small piece of conductive fabric where the arduino can be attached.  The the two pieces are places with the stitched facing each other crisscrossed with a piece of volostat in the center. When the sensor is pressed the velostat compresses and the resistance drops.

Programming: Initially I wanted to create a system that would allow me to compare the data for each sensor. I experimented with visual outputs and settled on a few. The first shows how the data is changing though a square that scales in size and changes position in reaction to the sensors behavior. After I completed this I wanted to be able to save the visual out put created with processing and use it to compare the behaviors. To enable this I created a graph that exports a PDF when the file is closed. When testing the sensors  I tried to keep the timing of the pressure of stretching consistent. When looking at the graphs created the ranges for the sensors can be seen.

PROCESSING:

Visual Output:

import processing.serial.*;

import fullscreen.*;

SoftFullScreen fs;

Serial myPort;        // The serial port

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

void setup () {

//size(1024, 768);

size(screen.width, screen.height);

noCursor();

//fullscreen

fs = new SoftFullScreen(this);

//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, 1024, 0, height);

// draw the rect:

smooth();

background(255);

noStroke();

rect((inByte/2)+200, 300, inByte/2, inByte/2);

fill(#3EC0E3);

smooth();

println(inByte);

}

}

Graph with PDF Export:

import processing.serial.*;

import fullscreen.*;

import processing.pdf.*;

boolean saveOneFrame = false;

SoftFullScreen fs;

Serial myPort;        // The serial port

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

void setup () {

size(screen.width, screen.height);

noCursor();

fs = new SoftFullScreen(this); //This helps with full screen

beginRecord(PDF, “Graph-####.pdf”); //For PDF

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

}

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, 1024, 200, height);

// draw the line:

//stroke(#16F0A9);//Strech Sensor 1

//stroke(#0A9CF5);//Strech Sensor 2

// stroke(#F0ED94);//Presure Sensor 1

//stroke(#F05416);//Presure Sensor 2

stroke(#94F0EF);//Presure Sensor 2

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

stroke(#403E3E);

line(0,590,3000,590); //base line

smooth();

println(inByte);

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

if (xPos >= 3000) {

xPos = 0;

//background(255);

}

else {

// increment the horizontal position:

xPos++;

}

}

if(saveOneFrame == true) {

endRecord();

saveOneFrame = false;

}

}

void mousePressed() {

saveOneFrame = true;

}

void stop() {

delay(1000);

endRecord();

}

Documentation:

]]>

Once upon a time, Ruffles the fidgety penguin decided that he was tired of being static, unmoving little plushie. “I want to be REAL!” He cried, wiggling his little soft head, and wishing upon a star. Of course, the said star was feeling quite benevolent that day, and promptly granted (the first part) of his wish, giving him the magical ability to rotate his head to see the world around him.

However, Ruffles was quite an antsy fella (hence his name), and unfortunately had a nervous twitch, which could not be cured.  The star was rather unsatisfied with this particular outcome, and decided to pick a less jumpy toy as his next subject. Tom the melty snowman was the toy of choice, as his outlook on life had recently been negatively affected by the recent Boston sun. His bored, resigned nature made him the perfect candidate. His unhurried gaze pleased the star, who proclaimed Iteration 2 a success!

The end.

Behind-The-Scenes- The making of Ruffles and Tom:

Ruffles the Fidgety Penguin:

Analog rotation sensor with two channels, Left and Right. Each channel is essentially a potentiometer, created by needle felting aluminum and steel fibers into wool so that the resistance increases when the angle of rotation is increased.  The analog pins A0 and A1 are connected to the potentiometers at the point where the penguin head points forward. The center clasp serves as a switch, as the top clasp is connected to a magnet, which remains in contact with the resistive surface. The bottom clasp is connected to the (-) terminal on the Arduino via a length of conductive fabric. The unstable nature of the signal received from the felted potentiometer can be attributed to the uneven density of the conductive fibers. The mass of conductive and non-conductive fibers also changes resistance with pressure, which causes even more fluctuation. This results in a jumpy image on the screen even after smoothing out the serial output in Arduino over 30 readings.

Resistance of potentiometer when penguin is facing forward- 13.2 ohms, turning away by 90 degrees – 4.83 Mohms, almost facing behind – 15.6Mohms

Tom the Melty Snowman:

Digital rotation sensor with 5 outputs- 2 left, 1 center, and 2 right. Works similarly to the analog sensor, except that the bottom half of rotation sensor has 5 magnets for the 5 outputs embedded below the felt layer and top half has 1 magnet. The jewelry clasp from the analog sensor was changed to the larger snap clasp for easier handling. The processing code was changed to scroll the image by 1 until the desired point of view was reached.

Inside Ruffles (Analog Rotation Sensor):

Arduino:

Processing:

Inside Tom (Digital Rotation Sensor):
Arduino:

Processing:

]]> http://newtextiles.media.mit.edu/?feed=rss2&p=1983 0 http://newtextiles.media.mit.edu/?p=1938 http://newtextiles.media.mit.edu/?p=1938#comments Sat, 19 Mar 2011 02:57:47 +0000 Sheralyn Woon http://newtextiles.media.mit.edu/?p=1938

My project for this week is focused on the difference in behavior of a stretch sensor following the direction of the yarn (weft) or perpendicularly across the direction of the yarn (warp). Knitting doesn’t really have a wrap or a weft but just to use familiar terms, I’ve chosen to use these.

I-cord, Basic Knit, Seed & Cable
I started with small samples of knitting, incorporating the conductive stainless steel thread or aluminum yarn. I used very simple basic patterns. And hooked up the samples to the Arduino in 2 ways: warp or weft. The I-cord was rather noisy, the signal was not consistent. For the basic knit pattern, it was difficult to see a difference in resistance at first as I had used the ellipse shape, but there seemed to be a difference in the size of the circle on the screen. I also found that when using the aluminum yarn the size of the circle was a bit larger. So I thought that I could exaggerate these differences by making a knitted resistor of a different shape using the aluminum yarn.

Warp Weft Resistor
Using garter stitch, wool & aluminum yarn are knit together. This knitted resistor has very clearly defined ribbing as a warp structure. Along the weft, small extensions were knitted in addition to original structure and helps us stretch out the more rigid ribbing in the center without displacing the alligator clips at the ends during testing. The extensions were also to make sure that warp and weft length were similar. I used the ellipse visualization. I was clear that along warp and weft this resistor was registering different resistances but somehow I couldn’t get a sense if my theory was correct.
After speaking to Leah about the Warp Weft Resistor and how it was reacting to the Arduino, I decided to change the programming and use a method of visualization that could let me see the magnitude of the resistance over time. I reverted back to the original programming but integrated some color by using code that Crystal had taught me. So now when the resistance is high, a long pink line registers. If the resistance is low, a short blue line registers.
Findings: Resistance along the warp is higher than that on the weft. The signal from the warp is steadier and varies less while the weft varies a lot and quite quickly. Range of resistance of the warp is slightly wider than that of the weft.
After playing with it for a while, I realized that when the resistor is hooked up along the weft, it can be used as a pressure sensor too.

Cable
I knitted this just to test the antithesis of my theory. Hence, using the stainless steel thread, I knitted a cable which has more rigidity than garter stitch. Resistance is generally low and doesn’t vary which might be caused by the cable which doesn’t stretch much.

Processing Code

// Graphing sketch

// This program takes ASCII-encoded strings
// from the serial port at 9600 baud and graphs them. It expects values in the
// range 0 to 1023, followed by a newline, or newline and carriage return

// Created 20 Apr 2005
// Updated 18 Jan 2008
// by Tom Igoe
// This example code is in the public domain.

import processing.serial.*;

Serial myPort; // The serial port
int xPos = 1; // horizontal position of the graph

void setup () {
// set the window size:
size(800, 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, 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);
int changing = int(map(inByte, 0, 1023, 0, 255));
inByte = map(inByte, 0, 1023, 0, height);

// draw the line:
stroke(changing,34,random(255));
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++;
}
}
}

For this assignment you will create a soft, flexible, textile-based sensor and a simple screen-based interface that displays information from the sensor.

Part 1. Felt, knit, sew, fuse, or crochet a soft sensor. Document your construction process with pictures. Write a paragraph that describes your sensor and a scenario for its use. If your sensor is a resistive sensor, use the multimeter to measure its resting and activated resistances and include this information in your paragraph.

Part 2. Connect your sensor to an Arduino (you will be loaned an Arduino for the duration of this assignment). Write a simple Arduino program that takes readings from your sensor and sends them to the computer. Write a simple Processing program that uses the data from the Arduino to create an interactive program–a small game–that can be controlled with your sensor. Take a video of your sensor controlling your program. Include your video and your Arduino and Processing code in your write-up. This tutorial will be useful. Note: don’t permanently attach your sensor to the Arduino. You will return the Arduino on March 29.

Create a post that documents your project as described above and add it to the Textile Sensor category.

Bring your projects to class on March 29 for demonstrations.