1.

ANALOG READ SERIAL

This example shows you how to read analog input from the physical world using a
potentiometer.
A potentiometer is a simple mechanical device that provides a varying amount of
resistance when its shaft is turned. By passing voltage through a potentiometer and into an
analog input on your board, it is possible to measure the amount of resistance produced by a
potentiometer (or pot for short) as an analog value. In this example you will monitor the
state of your potentiometer after establishing serial communication between your Arduino
and your computer running the Arduino Software (IDE).
Hardware Required
 Arduino Board
 10k ohm Potentiometer
Circuit
Connect the three wires from the potentiometer to your board. The first goes from one of
the outer pins of the potentiometer to ground. The second goes from the other outer pin of
the potentiometer to 5 volts. The third goes from the middle pin of the potentiometer to the
analog pin A0.

By turning the shaft of the potentiometer, you change the amount of resistance on either
side of the wiper, which is connected to the center pin of the potentiometer. This changes
the voltage at the center pin. When the resistance between the center and the side connected
to 5 volts is close to zero (and the resistance on the other side is close to 10k ohm), the
voltage at the center pin nears 5 volts. When the resistances are reversed, the voltage at the
center pin nears 0 volts, or ground. This voltage is the analog voltage that you're reading as
an input.
The Arduino boards have a circuit inside called an analog-to-digital converter or ADC that
reads this changing voltage and converts it to a number between 0 and 1023. When the
shaft is turned all the way in one direction, there are 0 volts going to the pin, and the input
value is 0. When the shaft is turned all the way in the opposite direction, there are 5 volts
going to the pin and the input value is 1023. In between, analogRead() returns a number
between 0 and 1023 that is proportional to the amount of voltage being applied to the pin.
Schematic

Code
In the sketch below, the only thing that you do in the setup function is to begin serial
communications, at 9600 bits of data per second, between your board and your computer
with the command:
Serial.begin(9600);
Next, in the main loop of your code, you need to establish a variable to store the resistance
value (which will be between 0 and 1023, perfect for an Int datatype) coming in from your
potentiometer:
int sensorValue = analogRead(A0);
Finally, you need to print this information to your serial monitor window. You can do this
with the command Serial.println() in your last line of code:
Serial.println(sensorValue);
Now, when you open your Serial Monitor in the Arduino Software (IDE) (by clicking the
icon that looks like a lens, on the right, in the green top bar or using the keyboard shortcut
Ctrl+Shift+M), you should see a steady stream of numbers ranging from 0-1023,
correlating to the position of the pot. As you turn your potentiometer, these numbers will
respond almost instantly.

/*
AnalogReadSerial
Reads an analog input on pin 0, prints the result to the Serial Monitor.
Graphical representation is available using Serial Plotter (Tools > Serial Plotter menu).
Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and
ground.
This example code is in the public domain.
https://www.arduino.cc/en/Tutorial/BuiltInExamples/AnalogReadSerial
*/
// the setup routine runs once when you press reset:
void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
}

// the loop routine runs over and over again forever:

void loop() {
// read the input on analog pin 0:
int sensorValue = analogRead(A0);
// print out the value you read:
Serial.println(sensorValue);
delay(1); // delay in between reads for stability
}
 2. DIGITAL READ SERIAL
A. Read a switch, print the state out to the Arduino Serial Monitor.
This example shows you how to monitor the state of a switch by establishing serial
communication between your Arduino and your computer over USB.
Hardware Required
 Arduino Board
 A momentary switch, button, or toggle switch
 10k ohm resistor
 hook-up wires
 breadboard
Circuit

Connect three wires to the board. The first two, red and black, connect to the two long
vertical rows on the side of the breadboard to provide access to the 5 volt supply and
ground. The third wire goes from digital pin 2 to one leg of the pushbutton. That same leg
of the button connects through a pull-down resistor (here 10k ohm) to ground. The other leg
of the button connects to the 5V supply.
Pushbuttons or switches connect two points in a circuit when you press them. When the
pushbutton is open (unpressed) there is no connection between the two legs of the
pushbutton, so the pin is connected to ground (through the pull-down resistor) and reads as
LOW, or 0. When the button is closed (pressed), it makes a connection between its two
legs, connecting the pin to 5 volts, so that the pin reads as HIGH, or 1.
If you disconnect the digital i/o pin from everything, its reading may change erratically.
This is because the input is "floating" - that is, it doesn't have a solid connection to voltage
or ground, and it will randomly return either HIGH or LOW. That's why you need a pull-
down resistor in the circuit.
Schematic

Code
In the program below, the very first thing that you do will in the setup function is to begin
serial communications, at 9600 bits of data per second, between your board and your
computer with the line:
Serial.begin(9600);
Next, initialize digital pin 2, the pin that will read the output from your button, as an input:
pinMode(2,INPUT);
Now that your setup has been completed, move into the main loop of your code. When your
button is pressed, 5 volts will freely flow through your circuit, and when it is not pressed,
the input pin will be connected to ground through the 10k ohm resistor. This is a digital
input, meaning that the switch can only be in either an on state (seen by your Arduino as a
"1", or HIGH) or an off state (seen by your Arduino as a "0", or LOW), with nothing in
between.
The first thing you need to do in the main loop of your program is to establish a variable to
hold the information coming in from your switch. Since the information coming in from the
switch will be either a "1" or a "0", you can use an
int
datatype. Call this variable
sensorValue
, and set it to equal whatever is being read on digital pin 2. You can accomplish all this with
just one line of code:
int sensorValue = digitalRead(2);
Once the board has read the input, make it print this information back to the computer as a
decimal value. You can do this with the command Serial.println() in our last line of code:
Serial.println(sensorValue);
Now, when you open your Serial Monitor in the Arduino Software (IDE), you will see a
stream of "0"s if your switch is open, or "1"s if your switch is closed.

B. DigitalReadSerial
Reads a digital input on pin 2, prints the result to the Serial Monitor
// digital pin 2 has a pushbutton attached to it. Give it a name:
int pushButton = 2;

// the setup routine runs once when you press reset:

void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
// make the pushbutton's pin an input:
pinMode(pushButton, INPUT);
}

// the loop routine runs over and over again forever:

void loop() {
// read the input pin:
int buttonState = digitalRead(pushButton);
// print out the state of the button:
Serial.println(buttonState);
delay(1); // delay in between reads for stability
}
 3. BLINKING OF A LED
A. Turn an LED on and off every second. This example shows the simplest thing you
can do with an Arduino to see physical output: it blinks the on-board LED.
Hardware Required
 Arduino Board
optional
 LED
 220 ohm resistor
Circuit
This example uses the built-in LED that most Arduino boards have. This LED is connected
to a digital pin and its number may vary from board type to board type. To make your life
easier, we have a constant that is specified in every board descriptor file. This constant
is LED_BUILTIN and allows you to control the built-in LED easily. Here is the
correspondence between the constant and the digital pin.
 D13 - 101
 D13 - Due
 D1 - Gemma
 D13 - Intel Edison
 D13 - Intel Galileo Gen2
 D13 - Leonardo and Micro
 D13 - LilyPad
 D13 - LilyPad USB
 D13 - MEGA2560
 D13 - Mini
 D6 - MKR1000
 D13 - Nano
 D13 - Pro
 D13 - Pro Mini
 D13 - UNO
 D13 - Yún
 D13 - Zero
If you want to light an external LED with this sketch, you need to build this circuit, where
you connect one end of the resistor to the digital pin correspondent to
the LED_BUILTIN constant. Connect the long leg of the LED (the positive leg, called the
anode) to the other end of the resistor. Connect the short leg of the LED (the negative leg,
called the cathode) to the GND. In the diagram below we show an UNO board that has D13
as the LED_BUILTIN value.
The value of the resistor in series with the LED may be of a different value than 220 ohms;
the LED will light up also with values up to 1K ohm.

Schematic

Code
After you build the circuit plug your Arduino board into your computer, start the Arduino
Software (IDE) and enter the code below. You may also load it from the menu
File/Examples/01.Basics/Blink . The first thing you do is to initialize LED_BUILTIN pin
as an output pin with the line
pinMode(LED_BUILTIN, OUTPUT);
In the main loop, you turn the LED on with the line:
digitalWrite(LED_BUILTIN, HIGH);
This supplies 5 volts to the LED anode. That creates a voltage difference across the pins of
the LED, and lights it up. Then you turn it off with the line:
digitalWrite(LED_BUILTIN, LOW);
That takes the LED_BUILTIN pin back to 0 volts, and turns the LED off. In between the on
and the off, you want enough time for a person to see the change, so the
delay()
commands tell the board to do nothing for 1000 milliseconds, or one second. When you use
the
delay()
command, nothing else happens for that amount of time. Once you've understood the basic
examples, check out the BlinkWithoutDelay example to learn how to create a delay while
doing other things.

B. Turns an LED on for one second, then off for one second, repeatedly.
Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO it is
attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to the correct LED
pin independent of which board is used. If you want to know what pin the on-board LED is
connected to on your Arduino model, check the Technical Specs of your board at:
https://www.arduino.cc/en/Main/Products

// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever

void loop() {
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
C. Fading a LED
Demonstrates the use of analog output to fade an LED.
This example demonstrates the use of the analogWrite() function in fading an LED off and
on. AnalogWrite uses pulse width modulation (PWM), turning a digital pin on and off very
quickly with different ratio between on and off, to create a fading effect.
Hardware Required
 Arduino board
 LED
 220 ohm resistor
 hook-up wires
 breadboard
Circuit
Connect the anode (the longer, positive leg) of your LED to digital output pin 9 on your
board through a 220 ohm resistor. Connect the cathode (the shorter, negative leg) directly
to ground.

Schematic
Code
After declaring pin 9 to be your ledPin, there is nothing to do in the setup() function of your
code.
The analogWrite() function that you will be using in the main loop of your code requires
two arguments: One telling the function which pin to write to, and one indicating what
PWM value to write.
In order to fade your LED off and on, gradually increase your PWM value from 0 (all the
way off) to 255 (all the way on), and then back to 0 once again to complete the cycle. In the
sketch below, the PWM value is set using a variable called brightness. Each time through
the loop, it increases by the value of the variable fadeAmount.

If brightness is at either extreme of its value (either 0 or 255), then fadeAmount is changed
to its negative. In other words, if fadeAmount is 5, then it is set to -5. If it's -5, then it's set
to 5. The next time through the loop, this change causes brightness to change direction as
well.

analogWrite() can change the PWM value very fast, so the delay at the end of the sketch
controls the speed of the fade. Try changing the value of the delay and see how it changes
the fading effect.

This example shows how to fade an LED on pin 9 using the analogWrite() function.
The analogWrite() function uses PWM, so if you want to change the pin you're using, be
sure to use another PWM capable pin. On most Arduino, the PWM pins are identified with
a "~" sign, like ~3, ~5, ~6, ~9, ~10 and ~11.
int led = 9; // the PWM pin the LED is attached to
int brightness = 0; // how bright the LED is
int fadeAmount = 5; // how many points to fade the LED by
// the setup routine runs once when you press reset:
void setup() {
// declare pin 9 to be an output:
pinMode(led, OUTPUT);
}
// the loop routine runs over and over again forever:
void loop() {
 // set the brightness of pin 9:
analogWrite(led, brightness);
// change the brightness for next time through the loop:
brightness = brightness + fadeAmount;
// reverse the direction of the fading at the ends of the fade:
if (brightness <= 0 || brightness >= 255) {
fadeAmount = -fadeAmount;
}
// wait for 30 milliseconds to see the dimming effect
delay(30);
}
 READ ANALOG VOLTAGE
This example shows you how to read an analog input on analog pin 0, convert the values
from analogRead() into voltage, and print it out to the serial monitor of the Arduino
Software (IDE).
Hardware Required
 Arduino Board
 10k ohm potentiometer
Circuit

Connect the three wires from the potentiometer to your board. The first goes to ground
from one of the outer pins of the potentiometer. The second goes to 5 volts from the other
outer pin of the potentiometer. The third goes from the middle pin of the potentiometer to
analog input 0.
By turning the shaft of the potentiometer, you change the amount of resistance on either
side of the wiper which is connected to the center pin of the potentiometer. This changes
the voltage at the center pin. When the resistance between the center and the side connected
to 5 volts is close to zero (and the resistance on the other side is close to 10 kilohms), the
voltage at the center pin nears 5 volts. When the resistances are reversed, the voltage at the
center pin nears 0 volts, or ground. This voltage is the analog voltage that you're reading as
an input.
The microcontroller of the board has a circuit inside called an analog-to-digital
converter or ADC that reads this changing voltage and converts it to a number between 0
and 1023. When the shaft is turned all the way in one direction, there are 0 volts going to
the pin, and the input value is 0. When the shaft is turned all the way in the opposite
direction, there are 5 volts going to the pin and the input value is 1023. In
between, analogRead() returns a number between 0 and 1023 that is proportional to the
amount of voltage being applied to the pin.
Schematic

Code
In the program below, the very first thing you'll do will be in the setup function, to begin
serial communication at 9600 bits of data per second, between your board and your
computer with the line:
Serial.begin(9600);
Next, in the main loop of your code, you need to establish a variable to store the resistance
value (which will be between 0 and 1023, perfect for an intdatatype) coming in from your
potentiometer:
int sensorValue = analogRead(A0);
To change the values from 0-1023 to a range that corresponds to the voltage the pin is
reading, you'll need to create another variable, a float, and do a little math. To scale the
numbers between 0.0 and 5.0, divide 5.0 by 1023.0 and multiply that by sensorValue :
float voltage= sensorValue * (5.0 / 1023.0);

Finally, you need to print this information to your serial monitor. You can do this with the
command Serial.println() in your last line of code:
Serial.println(voltage)
Now, when you open your Serial Monitor in the Arduino IDE (by clicking on the icon on
the right side of the top green bar or pressing Ctrl+Shift+M), you should see a steady
stream of numbers ranging from 0.0 - 5.0. As you turn the pot, the values will change,
corresponding to the voltage coming into pin A0.
/ ReadAnalogVoltage
Reads an analog input on pin 0, converts it to voltage, and prints the result to the
Serial Monitor.
Graphical representation is available using Serial Plotter (Tools > Serial Plotter menu).
Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and
ground.
// the setup routine runs once when you press reset:
void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
}
// the loop routine runs over and over again forever:
void loop() {
// read the input on analog pin 0:
int sensorValue = analogRead(A0);
// Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
float voltage = sensorValue * (5.0 / 1023.0);
// print out the value you read:
Serial.println(voltage);
}
 HOW TO WIRE AND PROGRAM A BUTTON
Learn how to wire and program a pushbutton to control an LED.
Pushbuttons or switches connect two points in a circuit when you press them. This example
turns on the built-in LED on pin 13 when you press the button.
Hardware
 Arduino Board
 Momentary button or Switch
 10K ohm resistor
 hook-up wires
 breadboard
Circuit

Connect three wires to the board. The first two, red and black, connect to the two long
vertical rows on the side of the breadboard to provide access to the 5 volt supply and
ground. The third wire goes from digital pin 2 to one leg of the pushbutton. That same leg
of the button connects through a pull-down resistor (here 10K ohm) to ground. The other
leg of the button connects to the 5 volt supply.
When the pushbutton is open (unpressed) there is no connection between the two legs of the
pushbutton, so the pin is connected to ground (through the pull-down resistor) and we read
a LOW. When the button is closed (pressed), it makes a connection between its two legs,
connecting the pin to 5 volts, so that we read a HIGH.
You can also wire this circuit the opposite way, with a pullup resistor keeping the input
HIGH, and going LOW when the button is pressed. If so, the behavior of the sketch will be
reversed, with the LED normally on and turning off when you press the button.
If you disconnect the digital I/O pin from everything, the LED may blink erratically. This is
because the input is "floating" - that is, it will randomly return either HIGH or LOW. That's
why you need a pull-up or pull-down resistor in the circuit.
Schematic

Code
/*
Button
Turns on and off a light emitting diode(LED) connected to digital pin 13, when
pressing a pushbutton attached to pin 2.
The circuit:
- LED attached from pin 13 to ground through 220 ohm resistor
- pushbutton attached to pin 2 from +5V
- 10K resistor attached to pin 2 from ground
- Note: on most Arduinos there is already an LED on the board
attached to pin 13.
// constants won't change. They're used here to set pin numbers:
const int buttonPin = 2; // the number of the pushbutton pin
const int ledPin = 13; // the number of the LED pin

// variables will change:

int buttonState = 0; // variable for reading the pushbutton status
void setup() {
// initialize the LED pin as an output:
 pinMode(ledPin, OUTPUT);
// initialize the pushbutton pin as an input:
pinMode(buttonPin, INPUT);
}

void loop() {
// read the state of the pushbutton value:
buttonState = digitalRead(buttonPin);

// check if the pushbutton is pressed. If it is, the buttonState is HIGH:

if (buttonState == HIGH) {
// turn LED on:
digitalWrite(ledPin, HIGH);
} else {
// turn LED off:
digitalWrite(ledPin, LOW);
}
}
 Analog In, Out Serial
Read an analog input pin, map the result, and then use that data to dim or brighten an LED.
This example shows you how to read an analog input pin, map the result to a range from 0
to 255, use that result to set the pulse width modulation (PWM) of an output pin to dim or
brighten an LED and print the values on the serial monitor of the Arduino Software (IDE).
Hardware Required
 Arduino Board
 Potentiometer
 Red LED
 220 ohm resistor
Circuit

Connect one pin from your pot to 5V, the center pin to analog pin 0 and the remaining pin
to ground. Next, connect a 220 ohm current limiting resistor to digital pin 9, with an LED
in series. The long, positive leg (the anode) of the LED should be connected to the output
from the resistor, with the shorter, negative leg (the cathode) connected to ground.
Schematic
Code
In the sketch below, after declaring two pin assignments (analog 0 for our potentiometer
and digital 9 for your LED) and two variables, sensorValue and outputValue, the only
things that you do in the setup() function is to begin serial communication.
Next, in the main loop, sensorValue is assigned to store the raw analog value read from the
potentiometer. Arduino has an analogRead range from 0 to 1023, and an analogWrite range
only from 0 to 255, therefore the data from the potentiometer needs to be converted to fit
into the smaller range before using it to dim the LED.

In order to convert this value, use a function called map():

outputValue = map(sensorValue, 0, 1023, 0, 255);
outputValue is assigned to equal the scaled value from the potentiometer. map() accepts
five arguments: The value to be mapped, the low range and high values of the input data,
and the low and high values for that data to be remapped to. In this case, the sensor data is
mapped down from its original range of 0 to 1023 to 0 to 255.
The newly mapped sensor data is then output to the analogOutPin dimming or brightening
the LED as the potentiometer is turned. Finally, both the raw and scaled sensor values are
sent to the Arduino Software (IDE) serial monitor window, in a steady stream of data.
/*
Analog input, analog output, serial output
Reads an analog input pin, maps the result to a range from 0 to 255 and uses the result to
set the pulse width modulation (PWM) of an output pin. Also prints the results to the Serial
Monitor.
The circuit:
- potentiometer connected to analog pin 0. Center pin of the potentiometer goes to the
analog pin. Side pins of the potentiometer go to +5V and ground.
- LED connected from digital pin 9 to ground

// These constants won't change. They're used to give names to the pins used:
const int analogInPin = A0; // Analog input pin that the potentiometer is attached to
const int analogOutPin = 9; // Analog output pin that the LED is attached to
int sensorValue = 0; // value read from the pot
int outputValue = 0; // value output to the PWM (analog out)
void setup() {
// initialize serial communications at 9600 bps:
Serial.begin(9600);
}
void loop() {
// read the analog in value:
sensorValue = analogRead(analogInPin);
// map it to the range of the analog out:
outputValue = map(sensorValue, 0, 1023, 0, 255);
// change the analog out value:
analogWrite(analogOutPin, outputValue);
// print the results to the Serial Monitor:
Serial.print("sensor = ");
Serial.print(sensorValue);
Serial.print("\t output = ");
Serial.println(outputValue);
// wait 2 milliseconds before the next loop for the analog-to-digital
// converter to settle after the last reading:
delay(2);
}