Analog In with an Arduino

Thanks to adafruit, who have a good FSR tutorial as well.

You know that the maximum input range of any analog input is from 0 to 5 volts. So if you wanted to know the voltage on an analog input pin at any point, how could you use the map function to get it?

(:toggle questionVoltage init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

// read the sensor: int analogValue = analogRead(A0); // map the result to a voltage range from 0 to 5 volts // using a floating point decimal variable (called a float): float voltage = map(analogValue, 0.0, 5.0); // print it out: Serial.println(voltage);

Now write a sketch to control the red LED with the first sensor (we'll call it the right hand sensor) and the green LED with the second sensor (we'll call it the left hand sensor). First, make two constants for the LED pin numbers, and two variables for the left and right sensor values.

(:toggle question4 init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

const int redLED = 10; // pin that the red LED is on const int greenLED = 11; // pin that the green LED is on int rightSensorValue = 0; // value read from the right analog sensor int leftSensorValue = 0; // value read from the left analog sensor

In the setup(), initialize serial communication at 9600 bits per second, and make the LED pins outputs.

(:toggle question5 init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

void setup() {

  // initialize serial communications at 9600 bps:
  Serial.begin(9600); 
  // declare the led pins as outputs:
  pinMode(redLED, OUTPUT);
  pinMode(greenLED, OUTPUT);

} (:sourceend:)

Start the main loop by reading the right sensor using analogRead(). Map its range to a range from 0 to 255. Then use analogWrite() to set the brightness of the LED from the mapped value. Print the sensor value out as well.

(:toggle question6 init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

(:title Analog In with an Arduino:)

In this lab, you'll learn how to connect a variable resistor to a microcontroller and read it as an analog input. You'll be able to read changing conditions from the physical world and convert them to changing variables in a program.

For this lab you will need to have the following parts:

Solderless breadboard

22-AWG hookup wire

[-Arduino Microcontroller \\

Light Emiting Diodes, LED

560-ohm (anything from 220 to 1K) and 10Kohm resistors

10Kohm potentiometer

Variable resistors

[-Flex sensors\\

Conect power and ground on the breadboard to power and ground from the microcontroller. On the Arduino module, use the 5V and any of the ground connections:

(Diagram made with Fritzing)

Add a potentiometer and LED

Connect a potentiometer to analog in pin 0 of the module, and an LED to digital pin 9:

(Diagram made with Fritzing)

Program the Module

Program your Arduino as follows:

First, establish some global variables: One to hold the value returned by the potentiometer, and another to hold the brightness value. Make a global constant to give the LED's pin number a name.

(:toggle question1 init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

const int ledPin = 9; // pin that the LED is attached to int analogValue = 0; // value read from the pot int brightness = 0; // PWM pin that the LED is on.

In the setup() method, initialize serial communications at 9600 bits per second, and set the LED's pin to be an output.

void setup() {

    // initialize serial communications at 9600 bps:
    Serial.begin(9600); 
    // declare the led pin as an output:
    pinMode(ledPin, OUTPUT);

In the main loop, read the analog value using analogRead() and put the result into the variable that holds the analog value. Then divide the analog value by 4 to get it into a range from 0 to 255. Then use the analogWrite() command to face the LED. Then print out the brightness value.

void loop() {

    analogValue = analogRead(A0);      // read the pot value
    brightness = analogValue /4;       //divide by 4 to fit in a byte
    analogWrite(ledPin, brightness);   // PWM the LED with the brightness value 
    Serial.println(brightness);        // print the brightness value back to the serial monitor

When you run this code, the LED should dim up and down as you turn the pot, and the brightness value should show up in the serial monitor.

Other variable resistors

You can use many different types of variable resistors for analog input. For example, the pink monkey in the photo below has his arms wired with flex sensors. These sensors change their resistance as they are flexed. When the monkey's arms move up and down, the values of the flex sensors change the brightness of two LEDs. The same values could be used to control servo motors, change the frequency on a speaker, or move servo motors.

Note: Flex sensors and force-sensing resistors melt easily, so unless you are very quick with a soldering iron, it's risky to solder directly to their leads. Here are three better solutions:

use wire wrapping wire
and a wire wrapping tool

use screw terminals
(if you have a row of three, you can
attach the fixed resistor as well)

use female headers

Thanks to adafruit, who have a good FSR tutorial as well.

Here's an example circuit much like the pink monkey circuit above, but with force-sensing resistors instead of flex sensors.

(Diagram made with Fritzing)

The circuit above works for any variable resistor. It's called a voltage divider. There are two voltage dividers, one on analog in 0 and one on analog in 1. The fixed resistor in each circuit should have the same order of magnitude as the variable resistor's range. For example, if you're using a flex sensor with a range of 50 - 100 kilohms, you might use a 47Kohm or a 100Kohm fixed resistor. If you're using a force sensing resistor that goes from inifinity ohms to 10 ohms, but most of its range is between 10Kohms and 10 ohms, you might use a 10Kohm fixed resistor.

The code above assumed you were using a potentiometer, which always gives the full range of analog input, which is 0 to 1023. Dividing by 4 gives you a range of 0 to 255, which is the full output range of the analogWrite() command. The voltage divider circuit, on the other hand, can't give you the full range. The fixed resistor in the circuit limits the range. You'll need to modify the code.

To find out your range, open the serial monitor and watch the printout as you press the FSR or flex the flex sensor. Note the maximum value and the minimum value. Then you can map the range that the sensor actually gives as input to the range that the LED needs as output. For example, if your photocell gives a range from 400 to 900, you'd do this:

(:source lang=arduino tabwidth=4 :) // map the sensor value from the input range (400 - 900, for example) to the output range (0-255): int brightness = map(sensorValue, 400, 900, 0, 255); analogWrite(ledPin, brightness); (:sourceend:)

Now write a sketch to control the red LED with the first sensor (we'll call it the right hand sensor) and the green LED with the second sensor (we'll call it the left hand sensor). First, make two constants for the LED pin numbers, and two variables for the left and right sensor values.

(:toggle question4 init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

In the setup(), initialize serial communication at 9600 bits per second, and make the LED pins outputs.

(:toggle question5 init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

  // initialize serial communications at 9600 bps:
  Serial.begin(9600); 
  // declare the led pins as outputs:
  pinMode(redLED, OUTPUT);
  pinMode(greenLED, OUTPUT);

Start the main loop by reading the right sensor using analogRead(). Map its range to a range from 0 to 255. Then use analogWrite() to set the brightness of the LED from the mapped value. Print the sensor value out as well.

(:toggle question6 init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

  rightSensorValue = analogRead(A0); // read the pot value

  // map the sensor value from the input range (400 - 900, for example) 
  // to the output range (0-255). Change the values 400 and 900 below
  // to match the range your analog input gives:
  int brightness = map(rightSensorValue, 400, 900, 0, 255); 

  analogWrite(redLED, brightness);  // set the LED brightness with the result
  Serial.println(rightSensorValue);   // print the sensor value back to the serial monitor

Finish the main loop by doing the same thing with the left sensor and the green LED.

(:toggle question7 init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

  // now do the same for the other sensor and LED:
  leftSensorValue = analogRead(A1); // read the pot value

  // map the sensor value to the brightness again. No need to
  // declare the variable again, since you did so above:
  brightness = map(leftSensorValue, 400, 900, 0, 255); 

  analogWrite(greenLED, brightness);  // set the LED brightness with the result
  Serial.println(leftSensorValue);   // print the sensor value back to the serial monitor

Get creative

This is a suggestion for the Stupid Pet Trick assignment. You can do any project you wish as long as it demonstrates your mastery of the lab exercises and good physical interaction. This is just one suggestion.

Make a luv-o-meter with analog inputs. A luv-o-meter is a device that measures a person's potential to be a lover, and displays it on a graph of lights. In gaming arcades, the luv-o-meter is usually a handle that a person grips, and his or her grip is measured either for its strength or its sweatiness. But your luv-o-meter can measure any analog physical quantity that you want, providing you have a sensor for it. Make sure the display is clear, so the participant knows what it means, and make sure it is responsive.

(:title Servo Motor Control with an Arduino:)

In this lab, you'll control a servomotor's position using the value returned from an analog sensor. Servos are the easiest way to start making motion with a microcontroller. Even though they don't turn 360 degrees, you can use them to create all sorts of periodic or reciprocating motions. Check out some of the Flying Pig mechanisms for ideas on how to make levers, cams, and other simple machines for making motion.

For this lab you'll need:

http://itp.nyu.edu/physcomp/images/labs/breadboard.jpg | Solderless breadboard http://itp.nyu.edu/physcomp/images/labs/hookup_wire.jpg | 22-AWG hookup wire http://itp.nyu.edu/physcomp/images/labs/arduino.jpg | [-Arduino Microcontroller \\

http://itp.nyu.edu/physcomp/images/labs/resistors.jpg | 10Kohm resistors

http://itp.nyu.edu/physcomp/images/labs/flex_sensors.jpg | [-Flex sensors\\

http://itp.nyu.edu/physcomp/images/labs/servo.JPG | RC Servomotor

Connect power and ground on the breadboard to power and ground from the microcontroller. On the Arduino module, use the 5V and any of the ground connections:

(Diagram made with Fritzing - download)

Connect an analog input sensor and a servo

Pick any analog input and connect it to Analog pin 0 as you did in the Analog Input and Output Lab. Then connect an RC servomotor to digital pin 2. The yellow wire of the servo goes to the pin, and the red and black wires go to +5V and ground, respectively.

Not all servos have the same wiring colors. For example, the Hextronik servos that come with Adafruit's ARDX kit use red for +5V,brown for ground, and mustrard yellow for control.

Attach:Attach:servo_control_fsr_bb.png Δ

(Diagram made with Fritzing

Program the Microcontroller

First, find out the range of your sensor by using analogRead() to read the sensor and printing out the results.

(:toggle question1 init=hide show='What does that look like?' hide='Let me figure it out':)

void setup() {

  Serial.begin(9600);		// initialize serial communications

}

void loop() {

  int analogValue = analogRead(A0); // read the analog input 
  Serial.println(analogValue);		// print it

}

Now, map the result of the analog reading to a range from 0 to 179, which is the range of the sensor in degrees. Store the mapped value in a local variable called servoAngle.

void setup() {

  Serial.begin(9600);		// initialize serial communications

}

void loop() {

  int analogValue = analogRead(A0); // read the analog input 
  Serial.println(analogValue);		// print it

  // if your sensor's range is less than 0 to 1023, you'll need to
  // modify the map() function to use the values you discovered:
  int servoAngle = map(analogValue, 0, 1023, 0, 255);

Finally, add the servo library at the beginning of your code, then make a variable to hold an instance of the library, and a variable for the servo's output pin. In the setup(), initialize your servo using servo.attach(). Then in your main loop, use servoAngle to set the servo's position.

1. include <Servo.h> // include the servo library

Servo servoMotor; // creates an instance of the servo object to control a servo int servoPin = 2; // Control pin for servo motor

void setup() {

  Serial.begin(9600);		// initialize serial communications
  servoMotor.attach(servoPin);  // attaches the servo on pin 2 to the servo object

}

void loop() {

  int analogValue = analogRead(A0); // read the analog input 
  Serial.println(analogValue);		// print it

  // if your sensor's range is less than 0 to 1023, you'll need to
  // modify the map() function to use the values you discovered:
  int servoAngle = map(analogValue, 0, 1023, 0, 255);

  // move the servo using the angle from the sensor:
  servoMotor.write(servoAngle);                  

// map the sensor value from the input range (400 - 900, for example) to the output range (0-255): int brightness = map(sensorValue, 400, 900, 0, 255); analogWrite(ledPin, brightness);

Now write a sketch to control the red LED with the first sensor (we'll call it the right hand sensor) and the green LED with the second sensor (we'll call it the left hand sensor). First, make two constants for the LED pin numbers, and two variables for the left and right sensor values.

(:toggle question4 init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

use wire wrapping wire \\and a wire wrapping tool

use screw terminals \\(if you have a row of three, you can \\attach the fixed resistor as well)

use female headers

Thanks to adafruit, who have a good FSR tutorial as well.

Note: Flex sensors and force-sensing resistors melt easily, so unless you are very quick with a soldering iron, it's risky to solder directly to their leads. Here are three better solutions:

Attach:fsrs_wirewrap.jpg Δ? | use wire wrapping wire and a wire wrapping tool Attach:fsrs_wirewrap.jpg Δ? | use screw terminals (if you have a row of three, you can attached the fixed resistor as well) Attach:fsrs_wirewrap.jpg Δ? | use female headers

Note: Flex sensors and force-sensing resistors melt easily, so unless you are very quick with a soldering iron, it's risky to solder directly to their leads. Here are three better solutions:

Attach:fsrs_wirewrap.jpg Δ? | use wire wrapping wire and a wire wrapping tool Attach:fsrs_wirewrap.jpg Δ? | use screw terminals (if you have a row of three, you can attached the fixed resistor as well) Attach:fsrs_wirewrap.jpg Δ? | use female headers

(:sourceend:)

const int ledPin = 9; // pin that the LED is attached to

sourceend

)

    // initialize serial communications at 9600 bps:
    Serial.begin(9600); 
    // declare the led pin as an output:
    pinMode(ledPin, OUTPUT);

    analogValue = analogRead(A0);      // read the pot value
    brightness = analogValue /4;       //divide by 4 to fit in a byte
    analogWrite(ledPin, brightness);   // PWM the LED with the brightness value 
    Serial.println(brightness);        // print the brightness value back to the serial monitor

(:toggle question7 init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

(Diagram made with Fritzing)

(Diagram made with Fritzing)

Now write a sketch to control the red LED with the first sensor (we'll call it the right hand sensor) and the green LED with the second sensor (we'll call it the left hand sensor). First, make two constants for the LED pin numbers, and two variables for the left and right sensor values.

(:toggle question4 init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

In the setup(), initialize serial communication at 9600 bits per second, and make the LED pins outputs.

(:toggle question5 init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

  // initialize serial communications at 9600 bps:
  Serial.begin(9600); 
  // declare the led pins as outputs:
  pinMode(redLED, OUTPUT);
  pinMode(greenLED, OUTPUT);

Start the main loop by reading the right sensor using analogRead(). Map its range to a range from 0 to 255. Then use analogWrite() to set the brightness of the LED from the mapped value. Print the sensor value out as well.

(:toggle question6 init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

  rightSensorValue = analogRead(A0); // read the pot value

  // map the sensor value from the input range (400 - 900, for example) 
  // to the output range (0-255). Change the values 400 and 900 below
  // to match the range your analog input gives:
  int brightness = map(rightSensorValue, 400, 900, 0, 255); 

  analogWrite(redLED, brightness);  // set the LED brightness with the result
  Serial.println(rightSensorValue);   // print the sensor value back to the serial monitor

Finish the main loop by doing the same thing with the left sensor and the green LED.

(:toggle question6 init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

  // now do the same for the other sensor and LED:
  leftSensorValue = analogRead(A1); // read the pot value

  // map the sensor value to the brightness again. No need to
  // declare the variable again, since you did so above:
  brightness = map(leftSensorValue, 400, 900, 0, 255); 

  analogWrite(greenLED, brightness);  // set the LED brightness with the result
  Serial.println(leftSensorValue);   // print the sensor value back to the serial monitor

Attach:analog_In_lab_pot_and_led_bb.png Δ Δ

(Diagram made with Fritzing)

(Diagram made with Fritzing)

Program your Arduino as follows:

First, establish some global variables: One to hold the value returned by the potentiometer, and another to hold the brightness value. Make a global constant to give the LED's pin number a name.

(:toggle question1 init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

In the setup() method, initialize serial communications at 9600 bits per second, and set the LED's pin to be an output.

(:toggle question2 init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

	// initialize serial communications at 9600 bps:
	Serial.begin(9600); 
	// declare the led pin as an output:
	pinMode(led, OUTPUT);

In the main loop, read the analog value using analogRead() and put the result into the variable that holds the analog value. Then divide the analog value by 4 to get it into a range from 0 to 255. Then use the analogWrite() command to face the LED. Then print out the brightness value.

(:toggle question3 init=hide show='I give up, how do I do that?' hide='Let me figure it out':)

	analogValue = analogRead(A0);	// read the pot value
	brightness = analogValue /4;	//divide by 4 to fit in a byte
	analogWrite(led, brightness);	// PWM the LED with the brightness value 
	Serial.println(brightness);		// print the brightness value back to the serial monitor

When you run this code, the LED should dim up and down as you turn the pot, and the brightness value should show up in the serial monitor.

( Here's an example circuit much like the pink monkey circuit above, but with force-sensing resistors instead of flex sensors.

(Diagram made with Fritzing)

The circuit above works for any variable resistor. It's called a voltage divider. There are two voltage dividers, one on analog in 0 and one on analog in 1. The fixed resistor in each circuit should have the same order of magnitude as the variable resistor's range. For example, if you're using a flex sensor with a range of 50 - 100 kilohms, you might use a 47Kohm or a 100Kohm fixed resistor. If you're using a force sensing resistor that goes from inifinity ohms to 10 ohms, but most of its range is between 10Kohms and 10 ohms, you might use a 10Kohm fixed resistor.

The code above assumed you were using a potentiometer, which always gives the full range of analog input, which is 0 to 1023. Dividing by 4 gives you a range of 0 to 255, which is the full output range of the analogWrite() command. The voltage divider circuit, on the other hand, can't give you the full range. The fixed resistor in the circuit limits the range. You'll need to modify the code.

To find out your range, open the serial monitor and watch the printout as you press the FSR or flex the flex sensor. Note the maximum value and the minimum value. Then you can map the range that the sensor actually gives as input to the range that the LED needs as output. For example, if your photocell gives a range from 400 to 900, you'd do this:

(Diagram made with Fritzing - download)

(Diagram made with Fritzing - download) (:cell:)

(Diagram made with Fritzing - download) (:cell:)

The code above assumes you are using a potentiometer, which always gives the full range of analog input, which is 0 to 1023. Dividing by 4 gives you a range of 0 to 255, which is the full output range of the analogWrite() command. The voltage divider circuit, on the other hand, can't give you the full range. The fixed resistor in the circuit limits the range. You'll need to modify the code. First find out your range, open the serial monitor and watch the printout as you wave your hand over the photocell. Note the maximum value and the minimum value. Then you can map the range that the photocell actually gives as input to the range that the LED needs as output. For example, if your photocell gives a range from 400 to 900, you'd do this:

(:div class=code :)

 // map the sensor vaue from the input range (400 - 900, for example) to the output range (0-255):
 int brightness = map(sensorValue, 400, 900, 0, 255);
 analogWrite(led, brightness);

(:divend:)

Here's an alternate version of the program above for this circuit:

(:div class=code :)

 int potPin = 0;    // Analog input pin that the potentiometer is attached to
 int sensorValue = 0;   // value read from the analog sensor
 int led = 9;    // PWM pin that the LED is on.  n.b. PWM 0 is on digital pin 9

 void setup() {
   // initialize serial communications at 9600 bps:
   Serial.begin(9600); 
   // declare the led pin as an output:
   pinMode(led, OUTPUT);
 }

 void loop() {
   sensorValue = analogRead(potPin); // read the pot value

   // map the sensor vaue from the input range (400 - 900, for example) 
   // to the output range (0-255). Change the values 400 and 900 below
   // to match the range your analog input gives:
   int brightness = map(sensorValue, 400, 900, 0, 255); 

   analogWrite(led, brightness);  // set the LED brightness with the result
   Serial.println(sensorValue);   // print the pot value back to the debugger pane
   delay(10);                     // wait 10 milliseconds before the next loop
 }

(:divend:)

   // declare the led pin as an output:
   pinMode(led, OUTPUT);

This is a suggestion for the Stupid Pet Trick assignment. You can do any project you wish as long as it demonstrates your mastery of the lab exercises and good physical interaction. This is just one suggestion.

(:div class=code :)

 int potPin = 0;    // Analog input pin that the potentiometer is attached to
 int potValue = 0;   // value read from the pot
 int led = 9;    // PWM pin that the LED is on.  n.b. PWM 0 is on digital pin 9

 void setup() {
   // initialize serial communications at 9600 bps:
   Serial.begin(9600); 
 }

 void loop() {
   potValue = analogRead(potPin); // read the pot value
   analogWrite(led, potValue/4);  // PWM the LED with the pot value (divided by 4 to fit in a byte)
   Serial.println(potValue);      // print the pot value back to the debugger pane
   delay(10);                     // wait 10 milliseconds before the next loop
 }

(:divend:)

Overview

(:title Analog In with an Arduino:)

(:toc Table of Contents:)

Parts

For this lab you will need to have the following parts:

Attach:arduino_analog_input_schem.png

Attach:arduino_bboard_power.jpg Δ

Attach:bb_pot.jpg Δ

http://itp.nyu.edu/physcomp/images/labs/bb_dualflex.jpg

(:table:)

http://itp.nyu.edu/physcomp/images/labs/shield_dualflex.jpg

http://itp.nyu.edu/physcomp/images/labs/bb_pot.jpg

  analogWrite(led, potValue/4);  // PWM the LED with the pot value (divided by 4 to fit in a byte)

int led = 9; // PWM pin that the LED is on. n.b. PWM 0 is on digital pin 9

(or a different\\

http://itp.nyu.edu/physcomp/images/labs/flex_sensors.jpg | Flex sensors
(you can use another
form of variable resistor)

http://itp.nyu.edu/physcomp/images/labs/flex_sensors.jpg | Flex sensors (you can use another form of variable resistor)

Breadboard version:

Breadboard Shield version:

http://itp.nyu.edu/physcomp/images/labs/shield_dualflex.jpg

Here's a closeup on the breadboard: http://itp.nyu.edu/physcomp/images/labs/bb_dualflex_b.jpg

(:table:) (:cellnr colspan=2:)

(:cellnr:)

(:cell:) Breadboard shield version:

(:tableend:)

table

)

(:cellnr colspan=2:)

(:cellnr:)

http://itp.nyu.edu/physcomp/images/labs/shield_dualflex.pg (:cell:) http://itp.nyu.edu/physcomp/images/labs/bb_dualflex.jpg (:tableend:)

http://itp.nyu.edu/physcomp/images/labs/bb_pot.jpg

http://itp.nyu.edu/physcomp/images/labs/shield_pot.jpg

http://itp.nyu.edu/physcomp/images/labs/bb_pot.JPG

http://itp.nyu.edu/physcomp/images/labs/shield_pot.JPG

http://itp.nyu.edu/physcomp/images/labs/pp_pot.JPG

http://itp.nyu.edu/physcomp/images/labs/shield_pot_led.JPG

http://itp.nyu.edu/physcomp/images/labs/bb_dualflex.JPG

http://itp.nyu.edu/physcomp/images/labs/shield_dualflex.JPG

http://itp.nyu.edu/physcomp/images/labs/monski_analog.JPG

Make a luv-o-meter with analog inputs. A luv-o-meter is a device that measures a person's potential to be a lover, and displays it on a graph of lights. In gaming arcades, the luv-o-meter is usually a handle that a person grips, and his or her grip is measured either for its strength or its sweatiness. But your luv-o-meter can measure any analog physical quantity that you want, providing you have a sensor for it. Make sure the display is clear, so the participant knows what it means, and make sure it is responsive.

%alt='Monski with analog sensors'http://itp.nyu.edu/physcomp/images/labs/monski_analog.JPG

http://itp.nyu.edu/physcomp/images/labs/arduino_analog_in2_schem.png

http://itp.nyu.edu/physcomp/images/labs/arduino_analog_in2.JPG

http://itp.nyu.edu/physcomp/images/labs/arduino_analog_input2_schem.png

http://itp.nyu.edu/physcomp/images/labs/arduino_analog_input2.JPG

http://itp.nyu.edu/physcomp/images/labs/arduino_analog_input2_schem.png

The circuit above works for any variable resistor. It's called a voltage divider. There are two voltage dividers, one on analog in 0 and one on analog in 1. The fixed resistor in each circuit should have the same order of magnitude as the variable resistor's range. For example, if you're using a flex sensor with a range of 50 - 100 kilohms, you might use a 47Kohm or a 100Kohm fixed resistor. If you're using a force sensing resistor that goes from inifinity ohms to 10 ohms, but most of its range is between 10Kohms and 10 ohms, you might use a 10Kohm fixed resistor.

Breadboard version:

Breadbiard shield version:

Program the Module

Program your Arduino with the following code:

int potPin = 0;    // Analog input pin that the potentiometer is attached to
int potValue = 0;   // value read from the pot
int led = 0;    // PWM pin that the LED is on.  n.b. PWM 0 is on digital pin 9

void setup() {
  // initialize serial communications at 9600 bps:
  Serial.begin(9600); 
}

void loop() {
  potValue = analogRead(potPin); // read the pot value
  analogWrite(led, potValue);    // PWM the LED with the pot value
  Serial.println(potValue);      // print the pot value back to the debugger pane
  delay(10);                     // wait 10 milliseconds before the next loop
}

When you run this code, the LED should dim up and down as you turn the pot, and the value of the pot should show up in the debugger pane.

Other variable resistors

You can use many different types of variable resistors for analog input. For example, the pink monkey in the photo below has his arms wired with flex sensors. These sensors change their resistance as they are flexed. When the monkey's arms move up and down, the values of the flex sensors change the brightness of two LEDs. The same values could be used to control servo motors, change the frequency on a speaker, or move servo motors.

Monkey's arms schematic:

Monkey's arms circuit:

The circuit above works for any variable resistor. It's called a voltage divider. The fixed resistor in this circuit should have the same order of magnitude as the variable resistor's range. For example, if you're using a flex sensor with a range of 50 - 100 kilohms, you might use a 47Kohm or a 100Kohm fixed resistor. If you're using a force sensing resistor that goes from inifinity ohms to 10 ohms, but most of its range is between 10Kohms and 10 ohms, you might use a 10Kohm fixed resistor.

Get creative

http://itp.nyu.edu/physcomp/images/labs/arduino_analog_input_schem.png

http://itp.nyu.edu/physcomp/images/labs/arduino_analog_input_schem.png

http://itp.nyu.edu/physcomp/images/labs/arduino_analog_input_schem.png

http://itp.nyu.edu/physcomp/images/labs/arduino_analog_in_schem.png

http://itp.nyu.edu/physcomp/images/labs/bboard_shield_pot_led.JPG

http://itp.nyu.edu/physcomp/images/labs/breadboard_shield.jpg

Add a potentiometer and LED

Connect a potentiometer to analog in pin 0 of the module, and an LED to digital pin 9:

http://itp.nyu.edu/physcomp/images/labs/arduino_pot_led_schem.png

http://itp.nyu.edu/physcomp/images/labs/arduino_pot_led.JPG

blah

http://itp.nyu.edu/physcomp/images/labs/potentiometer.jpg | 10Kohm potentiometer

Variable resistors

http://itp.nyu.edu/physcomp/images/labs/arduino_shield.jpg

Analog Input Lab

In this lab, you'll learn how to connect a variable resistor to a microcontroller and read it as an analog input. You'll be able to read changing conditions from the physical world and convert them to changing variables in a program.

For this lab you'll need:

http://itp.nyu.edu/physcomp/images/labs/breadboard.jpg | Solderless breadboard http://itp.nyu.edu/physcomp/images/labs/hookup_wire.jpg | 22-AWG hookup wire http://itp.nyu.edu/physcomp/images/labs/arduino.jpg | Arduino Microcontroller
module
http://itp.nyu.edu/physcomp/images/labs/leds.jpg | Light Emiting Diodes, LED http://itp.nyu.edu/physcomp/images/labs/resistors.jpg | 220-ohm and 10Kohm resistors

Prepare the breadboard

Conect power and ground on the breadboard to power and ground from the microcontroller. On the Arduino module, use the 5V and any of the ground connections:

http://itp.nyu.edu/physcomp/images/labs/arduino_bboard_power.jpg

If you're using an Arduino breadboard shield, there is a row of sockets connected to 5V on the analog in side of the breadboard, and a row connected to ground on the digital in side of the board:

http://itp.nyu.edu/physcomp/images/labs/arduino_shield_power.jpg

Analog Input Lab