Description:
For this lab, I wanted to test how much power our little DC motors have. Since it’s acknowledged that they don’t have much torque, I didn’t want to choose something too heavy, but I did want to extend the range of the spinning motion so that it would be visible from far away. Looking around my apartment, I happened to have a poster tube sitting around, which I realized would make the perfect object: it’s long but slender, doesn’t weigh much but it stable, and is round, so I could fairly easily spin it with the motor without getting too much vibration.

So, I created a monochrome version of a barber’s pole:

First, I used the potentiometer as the speed control so that I could “lock in” a spin speed:

But after that, I wanted to try out using the FSR so that I could control the spin while holding the motor, so that I’d have I/O coincidence. That’s what I’ll be demonstrating in class.

One interesting observation I had was that with a heavy-ish weight, the motor takes quite a bit of “revving” to get to a level of power sufficient to overcome the inertia. And then, after removing power, my barber pole keeps spinning for quite some time. Interesting to watch it in action.

Components:

• Arduino Uno
• breadboard
• 1 DC motor
• 1 Transistor
• 1 Diode
• 2 resistors (one 1KΩ, one 10KΩ)
• 1 FSR (or potentiometer)
• 1 poster tube, decorated
• piece of cork (to provide friction and hold the motor in place on the end of the tube)
• battery pack
• two AA batteries
• jumper wires

Code:
(This is the final code, using the FSR rather than the potentiometer.)


int potPin = 0; // select the input pin for the potentiometer/FSR
int motorPin = 9; // select the pin for the Motor
int val = 0; // variable to store the value coming from the sensor
void setup() {
Serial.begin(9600);
}
void loop() {
val = analogRead(potPin); // read the value from the sensor, between 0 - 1023
val = map(val, 0, 1023, 0, 255);
Serial.println(val);
analogWrite(motorPin, val); // analogWrite can be between 0-255
}


Description:
For this lab, I wanted to focus on transferring data from multiple variables and multiple sensors from Arduino into Processing. I was less concerned with what visualization to make than how to give someone more control over it and how to allow it to have multiple input streams. Because the photocell was too sensitive for easy daylight use, I stuck with the FSR for my main sensor. I kept the LED within the circuit so that it could provide me with a backup indication of the pressure on my sensor, and then I added three pots back into the circuit. Each pot controls RGB values, and can be adjusted independently. The FSR I covered with a stress-reliever type foam ball with a slit cut into it. This allowed me to slip it over the FSR and it could act as a diffuser for the squeeze pressure on the ball. This way I can squeeze on the ball in general and still affect the FSR value. The visualization responds quickly to changes in pressure and color. (The nice thing about using RGB values instead of RGB LEDs is that we can actually get additive white onscreen!)

I also ran into some problems in the making of this visualization: Processing was not correctly reading in the final value from the serial input. After troubleshooting to determine that the problem was indeed within Processing, I added in a dummy value as a final value in my Arduino output as a quick solution. I also had an issue where I was getting a “USB device drawing too much power” from my computer. After trying a few solutions, I realized that two of my pots had shifted on the desk and were touching bare wire at one spot. After rearranging and separating them, I was able to get the circuit working again.

Here is a GIF of my animation (I am squeezing with one hand and adjusting the pots with the other hand):

And my circuit:

Components:
– Arduino Uno
– breadboard
– 1 LED
– 1 220 ohm resistor
– 1 FSR
– 1 10 ohm resistor
– 3 potentiometers
– jumper wires

Arduino Code:

/*
Lab04 - Sensing: Photocells and FSR
Molly Mahar

void loop() {
// this will map the LED brightness according to the pressure placed on the FSR:
FSRcellReading = analogRead(A0);
//now we have to map 0-1023 to 0-255 since thats the range analogWrite uses.
LEDbrightness = map(FSRcellReading, 0, 1023, 0, 255);
// Also want to read in the values from the three pots, and map those to 0-255 RGB values:
rVal = map(analogRead(rPot), 0, 1023, 0, 255);
gVal = map(analogRead(gPot), 0, 1023, 0, 255);
bVal = map(analogRead(bPot), 0, 1023, 0, 255);
analogWrite(ledPin, LEDbrightness); // PWM the LED with the pot value (divided by 4 to fit in a byte)
//construct a message to Processing with multiple values in arduino
//we can't just send a string from here since it only officially understands 'bytes'
// Got help in this instance from this post: https://processing.org/discourse/beta/num_1193069410.html
Serial.print(FSRcellReading);
Serial.print(",");
Serial.print(rVal);
Serial.print(",");
Serial.print(gVal);
Serial.print(",");
Serial.print(bVal);
Serial.print(",");
// Not sure why I'm having this problem, but Processing was somehow not reading the last value?
// I checked in the serial monitor and it was getting sent from Arduino
// So I'm adding a final value into the serial printout, so that all my rgb values will be read in Processing
Serial.print(0,DEC);
Serial.print("|");
//Serial.println([FSRcellReading, rVal, gVal, bVal]);
delay(100); // pause at that level before looping through again
}


Processing Code:

/* PROCESSING SKETCH
* Based on the original ball code by Noura Howell
* Modified for Lab 4 by Molly Mahar
*/
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;
int ballSize = 0;
int rVal = 0;
int gVal = 0;
int bVal = 0;

//read the message in Processing
//original version of this code (then edited) from: https://processing.org/discourse/beta/num_1193069410.html
void serialEvent(Serial myPort){
String myString = myPort.readStringUntil(124); //the ascii value of the "|" character
if(myString != null ){
myString = trim(myString); //remove whitespace around our values
int inputs[] = int(split(myString, ','));
//now assign your values in processing
if(inputs.length == 5){
ballSize = inputs[0];
rVal = inputs[1];
gVal = inputs[2];
bVal = inputs[3];
}
}
}


Description:

For this lab, I wanted to play around with all of the options available to me. I began with the pot controlling the blinking rate, then added a potentiometer to control the fade. After working through a minor issue with the digitalOut vs. analogOut that prevented the fade from working properly with the blinking, I was able to figure out how to make the two potentiometers play nice with each other.

Then I decided that I wanted to use the third potentiometer to control the mapping between the three LEDs—to use the rotation as a signal for which LED should be lit and which should be dark. So I added the third potentiometer and then did some research (and used the serial monitor) to read what values were being output by that new pot. I then set four increments, and had each individual LED light up for the first three (low values would be red, mid-low values would be green, mid-high values would be blue). Then I set the highest value to map to having all three LEDs lit at the same time. By using the serial monitor to troubleshoot from the beginning, I was able to get it to work with a minimum of trouble. So my first pot controls the blink rate, my second pot controls the fade level, and the third pot controls which LEDs are lit.

Components:

• Arduino Uno
• Breadboard
• 3 potentiometers
• 3 LEDs (red, green, blue)
• 3 220Ω resistors
• jumper wires
• USB cable
• computer

Code:


// EXTRA CREDIT CODE: mapping a third potentiometer so that I can control individual LEDs to fire one at a time,
// or have all three fire at once (when third pot is maxed out)

if (mappingValue < 255) { analogWrite(redledPin, fadepotValue/4); // PWM the LED with the pot value (divided by 4 to fit in a byte) delay(blinkpotValue); // delay by the blink pot value in milliseconds digitalWrite(redledPin, LOW); // then blink the LEDs off } else if (mappingValue >= 255 and mappingValue <; 610) { analogWrite(greenledPin, fadepotValue/4); // PWM the LED with the pot value (divided by 4 to fit in a byte) delay(blinkpotValue); // delay by the blink pot value in milliseconds digitalWrite(greenledPin, LOW); // then blink the LEDs off } else if (mappingValue >= 610 and mappingValue < 770) { analogWrite(blueledPin, fadepotValue/4); // PWM the LED with the pot value (divided by 4 to fit in a byte) delay(blinkpotValue); // delay by the blink pot value in milliseconds digitalWrite(blueledPin, LOW); // then blink the LEDs off } else if (mappingValue >= 770) {
analogWrite(redledPin, fadepotValue/4); // PWM the LED with the pot value (divided by 4 to fit in a byte)
analogWrite(blueledPin, fadepotValue/4);
analogWrite(greenledPin, fadepotValue/4);
delay(blinkpotValue); // delay by the blink pot value in milliseconds
digitalWrite(redledPin, LOW); // then blink the LEDs off
digitalWrite(blueledPin, LOW);
digitalWrite(greenledPin, LOW);
}
delay(blinkpotValue); // pause before blinking back on (also allows loop to run and pots to be adjusted)
}


Description:

After experimenting with and testing out the serial monitor functionality of the Arduino environment and watching the fading color change program work, I chose cone coffee filters as my diffuser of choice. This was after much experimentation–initially, I’d had the three LEDs spaced a few rows apart on the breadboard, but this didn’t allow them to mix very well. So first, I modified my breadboard so that all the LEDs were touching each other.

I tried diffusing with the large cotton balls in class, but those didn’t allow enough light to pass through. I then tried different configurations of coffee filters, lightbulb housings, plastic storage containers, and more. The cone-type coffee filters worked best for me because they maintained structure around the LEDs, and having two stacked on top of each other allowed for more uniform diffusion.

I then modified the code so that a user can press r, g, or b and the LEDs will change based on the following equation: (#key presses/10)*255. This gives the percentage of light, and then applies that to the full value of 255.

Components:

• Arduino Uno
• Breadboard
• 3 LEDs (rgb)
• 3 220Ω Resistors
• 2 Coffee filters
• jumper wires
• USB cable
• laptop

Code:

/* Modified on 9/7/16 by Molly Mahar
*
* Serial RGB LED
* ---------------
* Serial commands control the brightness of R,G,B LEDs
*
* Command structure is "<colorCode><colorVal>", where "colorCode" is
* one of "r","g",or "b" and "colorVal" is a number 0 to 255.
* E.g. "r0" turns the red LED off.
* "g127" turns the green LED to half brightness
* "b64" turns the blue LED to 1/4 brightness
*
* Created 18 October 2006
* copyleft 2006 Tod E. Kurt <tod@todbot.com
* http://todbot.com/
*/

//read a string from the serial and store it in an array
//you must supply the array variable
void readSerialString (char *strArray) {
int i = 0;
if(!Serial.available()) {
return;
}
while (Serial.available()) {
strArray[i] = Serial.read();
i++;
}
}