I was sick for this lab, so I decided to see just how awake I was in bed. I decided to graph how much pressure I was applying to my husband pillow (that’s honestly what it’s called). The more pressure, the more likely I was asleep/resting.

Materials

• FSR
• Jumper wires
• Resistor
• Breadboard
• Arduino

Arduino Code:

<span class="coMULTI">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.

 http://www.arduino.cc/en/Tutorial/Graph
 */</span>

<span class="kw1">void</span> <span class="kw3">setup</span><span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span>
  <span class="co1">// initialize the serial communication:</span>
  <span class="kw1">Serial</span>.<span class="kw1">begin</span><span class="br0">(</span><span class="nu0">9600</span><span class="br0">)</span><span class="sy0">;</span>
<span class="br0">}</span>

<span class="kw1">void</span> <span class="kw3">loop</span><span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span>
  <span class="co1">// send the value of analog input 0:</span>
  <span class="kw1">Serial</span>.<span class="kw1">println</span><span class="br0">(</span><span class="kw1">analogRead</span><span class="br0">(</span>A0<span class="br0">)</span><span class="br0">)</span><span class="sy0">;</span>
  <span class="co1">// wait a bit for the analog-to-digital converter</span>
  <span class="co1">// to stabilize after the last reading:</span>
  <span class="kw1">delay</span><span class="br0">(</span><span class="nu0">2</span><span class="br0">)</span><span class="sy0">;</span>
<span class="br0">}</span>

Processing Code:

import processing.serial.*;
 String portname = "/dev/cu.usbmodem1421"; // or "COM5"
 Serial port;
 String buf="";
 int cr = 13; // ASCII return == 13
 int lf = 10; // ASCII linefeed == 10

int serialVal = 0;
 float xPos = 0; // horizontal position of the graph
 float yPos = 0; // vertical position of the graph

void setup() {
 size(800,600); // window size
 // List all the available serial ports
 port = new Serial(this, portname, 9600);
 background(#081640);
 }

void serialEvent (Serial myPort) {
 // get the byte:
 int inByte = myPort.read();
 // print it:
 println(inByte);
 yPos = height - inByte;
 }

void draw () {
 // draw the line in a pretty color:
 stroke(#FFD700);
 line(xPos, height, xPos, yPos);
 // at the edge of the screen, go back to the beginning:
 if (xPos >= width) {
 xPos = 0;
 // clear the screen by resetting the background:
 background(#081640);
 } else {
 // increment the horizontal position for the next reading:
 xPos++;
 }
 }

My lab project this week consists of a squeezable, glowing orb and a fractal generator. The results are a bit kooky. I reused a soft silicon casing we created for a past project and placed the pressure sensor between the soft casing and the hard plastic kernel.

For my visualization, I played around with the Mandelbrot sketch example in Processing, making it into a sequential, frame-by-frame visualization rather than a static image. I accelerated the fractal growth with greater pressure on the orb, but as that was hard to see, I also changed the background color slightly to show when pressure was applied. The next step might be to try out algorithmic visualizations that are not fractals, as later evolution is hard to see as the fractals get smaller.

Arduino Code:

/*
* Andrew Chong
* Alternating RGB Fade with Potentiometers
* Modified from Clay Shirky <clay.shirky@nyu.edu> 
*/

// Output
int redPin   = 9;   // Red LED,   connected to digital pin 9
int greenPin = 10;  // Green LED, connected to digital pin 10
int bluePin  = 11;  // Blue LED,  connected to digital pin 11

float red_direction = 1; 
float blue_direction = 1; 
float green_direction = 1; 
float pressure; 

// brightness 
float blue_brightness = 0; 
float red_brightness = 0;
float green_brightness = 0; 

// Program variables
float redVal   = 255; // Variables to store the values to send to the pins
float greenVal = 255;   
float blueVal  = 0;

int i = 0;     // Loop counter    
int j = 0; // display counter 
int wait = 500; // 50ms (.05 second) delay; shorten for faster fades
int DEBUG = 1; // DEBUG counter; if set to 1, will write values back via serial

void setup()
{
  pinMode(redPin,   OUTPUT);   // sets the pins as output
  pinMode(greenPin, OUTPUT);   
  pinMode(bluePin,  OUTPUT);         // If we want to see the pin values for debugging...
    Serial.begin(9600);  // ...set up the serial ouput on 0004 style
}

// Main program
void loop()
{
  //blue_brightness = analogRead(A0)*3/(float)1023;
  //red_brightness =  analogRead(A5)*3/(float)1023;
  //green_brightness =  analogRead(A1)*3/(float)1023;
  i += 5;      // Increment counter
  j += 1; 

  delay(wait);
  Serial.println(int(analogRead(A0)/100));
  pressure = analogRead(A0);

  greenVal = (pressure/1000)*255;
  //Serial.println("red:");
  //Serial.println("red:");
  //Serial.println(greenVal);
  analogWrite(greenPin, greenVal); 

/*
if (DEBUG) { // If we want to read the output
    DEBUG += 1;     // Increment the DEBUG counter
    if (DEBUG > 20) // Print every 10 loops
    {
      DEBUG = 1;     // Reset the counter
      Serial.print(i);       // Serial commands in 0004 style
      Serial.print("\t");    // Print a tab
      Serial.print("R:");    // Indicate that output is red value
      Serial.print(redVal);  // Print red value
      Serial.print("\t");    // Print a tab
      Serial.print("G:");    // Repeat for green and blue...
      Serial.print(greenVal);
      Serial.print("\t");    
      Serial.print("B:");    
      Serial.println(blueVal); // println, to end with a carriage return
    }
  }
  */ 

  //delay(wait); // Pause for 'wait' milliseconds before resuming the loop
}

Processing code:

/**
 * The Mandelbrot Set
 * by Daniel Shiffman.  
 * 
 * Simple rendering of the Mandelbrot set.
 */

import processing.serial.*;
// Change this to the portname your Arduino board
String portname = "/dev/cu.usbmodem1421"; // or "COM5"
Serial port;
String buf="";
int cr = 13; // ASCII return == 13
int lf = 10; // ASCII linefeed == 10
int serialVal = 0;
int currentVal = 10; 
int r = 106;
int g = 0;
int b = 209;

void setup() {
  size(1200,800);
  frameRate(2);  // Animate slowly
   port = new Serial(this, portname, 9600); 
}

void draw() {
 // Establish a range of values on the complex plane
// A different range will allow us to "zoom" in or out on the fractal

// It all starts with the width, try higher or lower values
float w = 4;
float h = (w * height) / width;

// Start at negative half the width and height
float xmin = -w/2;
float ymin = -h/2;

// Make sure we can write to the pixels[] array.
// Only need to do this once since we don't do any other drawing.
loadPixels();

currentVal = currentVal + 1 + serialVal;
// Maximum number of iterations for each point on the complex plane
int maxiterations = currentVal ;

// x goes from xmin to xmax
float xmax = xmin + w;
// y goes from ymin to ymax
float ymax = ymin + h;

// Calculate amount we increment x,y for each pixel
float dx = (xmax - xmin)/(width);
float dy = (ymax - ymin)/(height);

// Start y
float y = ymin;
for (int j = 0; j < height; j++) {
  // Start x
  float x = xmin;
  for (int i = 0; i < width; i++) {

    // Now we test, as we iterate z = z^2 + cm does z tend towards infinity?
    float a = x;
    float b = y;
    int n = 0;
    while (n < currentVal) { float aa = a * a; float bb = b * b; float twoab = 2.0 * a * b; a = aa - bb + x; b = twoab + y; // Infinty in our finite world is simple, let's just consider it 16 if (dist(aa, bb, 0, 0) > 16) {
        break;  // Bail
      }
      n++;
    }

    // We color each pixel based on how long it takes to get to infinity
    // If we never got there, let's pick the color black
    if (n == maxiterations) {
      pixels[i+j*width] = color(0);
    } else {
      // Gosh, we could make fancy colors here if we wanted
      float norm = map(n, 0, maxiterations, 0, 1);
      /*
      if (r>254) {
      r = 0; 
      }
      if (g>254) {
       g = 0;
      }
      if (b>254) {
        b = 0;
      }
      */
      //r = r + 1;
      //b = b + 1;
      //g = g +1; 
      pixels[i+j*width] = color(0,g,b); 
    }
    x += dx;
  }
  y += dy;
}

updatePixels();

}

// called whenever serial data arrives
void serialEvent(Serial p) {
 int c = port.read();
 if (c != lf && c != cr) {
 buf += char(c);
 }
 if (c == lf) {
 serialVal = int(buf);

 println("val="+serialVal); 
 buf = ""; 
 }
 if (serialVal>5){
 //r = int(random(255));
 if (g==0) {
   g = 20; 
 }
 else if (g==20){
 g = 0;
 }
 print(g);
 //b = int(random(255)); 
 //print(b);
 }
}

Description

I attached my FSR to a pair of tongs and through the visualization, you can see how much force you’re using to hold/pick up an object. My visualization makes use of color, size and speed to demonstrate changes in force applied. Squared move diagonally across the screen and as the pressure increases, so does their speed and they grow in size too. At maximum force, the background color  becomes a bright green and is meant to grab the user’s attention or alert her.

Components

Arduino

Bread board

1 10 kΩ resistor

Jumper cables

1 FSR

Tongs

Arduino code

int fsrAnalogPin = 0; // FSR is connected to analog 0
int LEDpin = 11; // connect Red LED to pin 11 (PWM pin)
int fsrReading; // the analog reading from the FSR resistor divider
int LEDbrightness;

void setup(void) {
Serial.begin(9600); // We’ll send debugging information via the Serial monitor
pinMode(LEDpin, OUTPUT);
}

void loop(void) {
fsrReading = analogRead(fsrAnalogPin);
// Serial.print(“Analog reading = “);
// Serial.println(fsrReading);

// we’ll need to change the range from the analog reading (0-1023) down to the range
// used by analogWrite (0-255) with map!
LEDbrightness = map(fsrReading, 0, 1023, 0, 255);
// LED gets brighter the harder you press
analogWrite(LEDpin, LEDbrightness);

delay(100);
Serial.println(fsrReading); // for processing
}

Processing code

/* PROCESSING SKETCH
* FSR Visualization – Moving squares
* Reema Naqvi
*/

import processing.serial.*;
// Change this to the portname your Arduino board
String portname = “/dev/cu.usbmodem1411”; // or “COM5″
Serial port;
String buf=””;
int cr = 13; // ASCII return == 13
int lf = 10; // ASCII linefeed == 10

int serialVal = 0;
int rgbValr;
int rgbValg;
int rgbValb;
int moveX = 0;
int moveY = 0;
void setup() {
size(1200,700);
frameRate(20);
smooth();
background(0, 10, 20);
noStroke();
port = new Serial(this, portname, 9600);
}

void draw() {
// erase the screen

rgbValr = 255-serialVal/4;
rgbValg = 255-serialVal/9;
rgbValb = 255-serialVal/4;
background(rgbValr, rgbValg, rgbValb);

fill (255,0,190);
rect(moveX, moveY, serialVal/20 , serialVal/20);
moveX = moveX+serialVal/30;
moveY = moveY+serialVal/30;
if (moveY >= height) {
moveY = 0;
moveX = 0;
}
if (moveX >= width) {
moveX = 0;
moveY = 0;
}

rect(moveX+300, moveY, serialVal/15 , serialVal/15);
moveX = moveX+serialVal/30;
moveY = moveY+serialVal/40;
if (moveY >= height) {
moveY = 0;
moveX = 0;
}
if (moveX >= width) {
moveX = 0;
moveY = 0;
}

rect(moveX+600, moveY+100, serialVal/10 , serialVal/10);
moveX = moveX+serialVal/30;
moveY = moveY+serialVal/40;
if (moveY >= height) {
moveY = 0;
moveX = 0;
}
if (moveX >= width) {
moveX = 0;
moveY = 0;
}

rect(moveX – 200, moveY+300, serialVal/40 , serialVal/40);
moveX = moveX+serialVal/30;
moveY = moveY+serialVal/40;
if (moveY >= height) {
moveY = 0;
moveX = 0;
}
if (moveX >= width) {
moveX = 0;
moveY = 0;
}

rect(moveX-100, moveY+400, serialVal/25 , serialVal/25);
moveX = moveX+serialVal/30;
moveY = moveY+serialVal/40;
if (moveY >= height) {
moveY = 0;
moveX = 0;
}
if (moveX >= width) {
moveX = 0;
moveY = 0;
}

rect(moveX+1150, moveY+400, serialVal/8 , serialVal/8);
moveX = moveX+serialVal/30;
moveY = moveY+serialVal/40;
if (moveY >= height) {
moveY = 0;
moveX = 0;
}
if (moveX >= width) {
moveX = 0;
moveY = 0;
}

rect(moveX, moveY+200, serialVal/15 , serialVal/15);
moveX = moveX+serialVal/30;
moveY = moveY+serialVal/40;
if (moveY >= height) {
moveY = 0;
moveX = 0;
}
if (moveX >= width) {
moveX = 0;
moveY = 0;
}

rect(moveX+1000, moveY, serialVal/20 , serialVal/20);
moveX = moveX+serialVal/30;
moveY = moveY+serialVal/30;
if (moveY >= 300) {
moveY = 0;
moveX = 0;
}
if (moveX >= width) {
moveX = 0;
moveY = 0;
}
rect(moveX+600, moveY+400, serialVal/8 , serialVal/8);
moveX = moveX+serialVal/30;
moveY = moveY+serialVal/40;
if (moveY >= height) {
moveY = 0;
moveX = 0;
}
if (moveX >= width) {
moveX = 0;
moveY = 0;
}

}

// called whenever serial data arrives
void serialEvent(Serial p) {
int c = port.read();
if (c != lf && c != cr) {
buf += char(c);
}
if (c == lf) {
serialVal = int(buf);
println(“val=”+serialVal);
buf = “”;
}
}

My program lights up different LEDs on the Arduino based on the pressure applied to the FSR. On low pressure, it’s green; on medium, blue and on higher pressure, red. It can be used in trash cans to check for the amount of trash inside, or installed under the insoles of shoes to check how relaxed the fit is.

const int ledGreen = 7; // Level Min
const int ledBlue = 4; // Level Medium
const int ledRed = 2; // Level Full
int fsrPin = A0; 
int fsrReading; 
void setup(void) {
   // Debugging information via the Serial monitor
   Serial.begin(9600);
   pinMode(ledRed, OUTPUT);
   pinMode(ledBlue, OUTPUT);
   pinMode(ledGreen, OUTPUT);
}
void loop(void) {
   fsrReading = analogRead(fsrPin); 
   if (fsrReading <=512) {
      digitalWrite(ledRed, LOW);
      digitalWrite(ledGreen, LOW);
      digitalWrite(ledBlue, LOW);
   }
   if (fsrReading > 512 && fsrReading <= 600) {
      digitalWrite(ledRed, LOW);
      digitalWrite(ledGreen, HIGH);
      digitalWrite(ledBlue, LOW);
   }
   if (fsrReading > 600 && fsrReading <= 680) {
      digitalWrite(ledRed, LOW);
      digitalWrite(ledGreen, LOW);
      digitalWrite(ledBlue, HIGH);
   }
   if (fsrReading > 680) {
      digitalWrite(ledRed, HIGH);
      digitalWrite(ledGreen, LOW);
      digitalWrite(ledBlue, LOW);
   }
   //Serial.print("Analog reading = ");
   Serial.println(fsrReading); // Raw analog reading
   delay(250); // Slow down the output for easier reading
}

For this lab, I chose to take a modern approach to Morse Code and where the input signals come from. For my project, the dots come from keyboard inputs and the dashes come from FSR presses and together, you get a visual of the dots and spaces for the dashes. The blue LED also flashes in accordance with the FSR presses.

Components:

• Arduino Uno
• Breadboard
• 1 force sensor
• 1 220Ω resistors
• 1 10Ω resistor
•  wires

Arduino code #1:

int photocellPin = 0; // select the input pin for the potentiometer
int fsrPin =11;
int bPin = 11; // select the pin for the LED
 
int fsrVal;
int photocellVal; // variable to store the value coming from the sensor
 
int counter;
 
int THRESHOLD = 500;
 
void setup() {
 photocellVal = 0;
 fsrVal = 0;
 counter = 0; 
 Serial.begin(9600);
}
 
void loop() {
 fsrVal = analogRead(fsrPin); // read the value from the sensor, between 0 - 1024
 
 analogWrite(bPin, fsrVal/4);
 
 photocellVal = analogRead(photocellPin);
 
 if(photocellVal>THRESHOLD)
 {
 analogWrite(bPin, photocellVal/4);
 if(counter%300==0)
 {
// Serial.print(photocellVal);
 Serial.print("1");
 }
 }
 else
 {
 analogWrite(bPin, 0);
 if(counter%300==0)
 {
 Serial.print("0");
 }
 }
 
 counter++;
}

Processing code:

adapted from :http://courses.ischool.berkeley.edu/i262/s13/content/stlim/lab-submission-4-photocell-and-fsr?destination=node%2F909

import processing.serial.*;
 
// Change this to the portname your Arduino board
String portname = "/dev/tty.usbmodem1411";
Serial port;
String buf="";
int cr = 13; // ASCII return == 13
int lf = 10; // ASCII linefeed == 10
 
int radius = 50;
int gapX = 1;
int gapY = 3;
int windowX = 1000;
int windowY = 720;
int marginX = 40;
int marginY = 40;
int x = marginX;
int y = marginY;
 
boolean gap = false;
boolean init = true;
 
void setup() {
 size(1200, 720);
 frameRate(10);
 smooth();
 background(255, 200, 200);
 noStroke();
 port = new Serial(this, portname, 9600); 
}
void draw() {
}
 
void keyPressed() {
 if(key == ' ') {
 background(40,40,40); // erase screen
 }
 else {
 int x = int(random(0,width));
 int y = int(random(0,height));
 drawball();
 }
}
 
// draw balls
void drawball() {
 ellipse(x,y,radius,radius);
 x+=3;
// x += 2*radius + gapX;
 
 if(x>windowX-marginX) {
 x = marginX;
 y += 2*radius + gapY;
 }
}
// called whenever serial data arrives
void serialEvent(Serial p) {
 int serialVal = 0;
 int c = port.read();
 // called whenever serial data arrives
 if (c != lf && c != cr) {
 buf += char(c);
 }
 if (c == lf) {
 serialVal = int(buf);
 println("val="+serialVal); 
 buf = ""; 
 }

if(serialVal==0 && init) {
 
 }
 else if(serialVal == 0) {
 if(!gap) {
 x += 2*radius + gapX;
 }
 
 gap = true;
 }
 else {
 init = false;
 gap = false;
 drawball();
 x+=radius/5;
 }
}

Description:

I thought there were two parts to the assignment: 1. making a graphic that reacts to FSR

2. making a reactive graphic that coincides w a pressure sensor application.

so for 2.

I thought of making a graphic that can tell you if you are pressing on your cellphone and hopefully warn you before you crack it.

Components:

• Arduino Uno
• Breadboard
• 1 force sensor
• 1 220Ω resistors
• 1 10Ω resistor
•  wires

Part 1 graphic is a sort of abstract pattern of lines and circles. I thought it was interesting that the lines rotate when you apply serialVal to the variables.

— processing code —

String portname = “/dev/cu.usbmodem1421”; // or “COM5″
Serial port;
String buf=””;
int cr = 13; // ASCII return == 13
int lf = 10; // ASCII linefeed == 10

int serialVal = 0;

void setup() {
size(640,640);
frameRate(10);
smooth();
background(40,40,40);
noStroke();
port = new Serial(this, portname, 9600);
}

void draw() {
// erase the screen
background(100, 40, 40);

// draw the ball
noFill();
stroke(200);
strokeWeight(.5);
line(150,serialVal,serialVal,100);
line(100,serialVal,serialVal,150);
ellipse(serialVal, serialVal, 50 + serialVal, 50 + serialVal);

strokeWeight(1);
line(200,serialVal,serialVal,75);
line(75,serialVal,serialVal,200);
ellipse(serialVal, serialVal, serialVal, serialVal);

strokeWeight(2);
line(250,serialVal,serialVal,55);
line(55,serialVal,serialVal,250);
ellipse(serialVal, serialVal, serialVal -50, serialVal – 50);

strokeWeight(2.5);
line(300,serialVal,serialVal,35);
line(35,serialVal,serialVal,300);
ellipse(serialVal, serialVal, serialVal -150, serialVal – 150);

strokeWeight(3.5);
line(500,serialVal,serialVal,15);
line(15,serialVal,serialVal,500);

}

// called whenever serial data arrives
void serialEvent(Serial p) {
int c = port.read();
if (c != lf && c != cr) {
buf += char(c);
}
if (c == lf) {
serialVal = int(buf);
println(“potValue=”+serialVal);
buf = “”;
}
}

+ + + + +

Part 2 graphic I can’t really create an actual connection between the cellphone and the graphic so I made a visual mockup on computer monitor where I overlay the Processor sketch window over a photo of a cellphone.

if you press on the center of the phone, the screen turns from black to red (the universal warning color)  and the text

“—hey— watch it.” comes up

—processing code—

String portname = “/dev/cu.usbmodem1421”; // or “COM5″
Serial port;
String buf=””;
int cr = 13; // ASCII return == 13
int lf = 10; // ASCII linefeed == 10

int serialVal = 0;

void setup() {
size(325,560);
frameRate(10);
smooth();
background(40,40,40);
noStroke();
port = new Serial(this, portname, 9600);
}

void draw() {

background(serialVal, serialVal-155, serialVal-155);
stroke(255,0,0);
fill(serialVal, serialVal, serialVal);
textSize(15);
text(“—hey—”, 130,260);
text(“watch it.”, 130, 300);

}

// called whenever serial data arrives
void serialEvent(Serial p) {
int c = port.read();
if (c != lf && c != cr) {
buf += char(c);
}
if (c == lf) {
serialVal = int(buf);
println(“potValue=”+serialVal);
buf = “”;
}
}