Experiment 1: Blinking of a LED

Introduction

LEDs are small, powerful lights that are used in many different applications. To start off,
we will work on blinking an LED, the Hello World of microcontrollers. That’s right - it’s as
simple as turning a light on and off. It might not seem like much, but establishing this important
baseline will give you a solid foundation as we work toward more complex experiments.

Parts Needed

You will need the following parts:

 Arduino Uno R3

 1x LED

 1x 330Ω Resistor

 2x Jumper Wires

Circuit Diagram for Arduino

int led = 13;

void setup() {
pinMode(led, OUTPUT);
}

void loop() {
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
Experiment 2:

Controlling the brightness of an LED Using a potentiometer

In this circuit you’ll work with a potentiometer.

A potentiometer is also known as a variable resistor. When powered with 5V, the middle
pin outputs a voltage between 0V and 5V, depending on the position of the knob on the
potentiometer. A potentiometer is a perfect demonstration of a variable voltage divider circuit.
The voltage is divided proportionate to the resistance between the middle pin and the ground pin.
In this circuit, you’ll learn how to use a potentiometer to control the brightness of an LED.

Parts Needed

You will need the following parts:

 Arduino Uno

 1x LED

 1x 330Ω Resistor

 6x Jumper Wires

 1x Potentiometer

Circuit Diagram for Arduino:

// Example sketch 02
int sensorPin = 0; // The potentiometer is connected to analog pin 0

int ledPin = 13; // The LED is connected to digital pin 13

void setup() // this function runs once when the sketch starts up
{
pinMode(ledPin, OUTPUT);

}
void loop() // this function runs repeatedly after setup() finishes
{

int sensorValue;

sensorValue = analogRead(sensorPin);

digitalWrite(ledPin, HIGH); // Turn the LED on

delay(sensorValue); // Pause for sensorValue milliseconds

digitalWrite(ledPin, LOW); // Turn the LED off

delay(sensorValue); // Pause for sensorValue milliseconds

}
Experiment 3:

Create unique color combinations Using RGB LED

Introduction
You know what’s even more fun than a blinking LED? Changing colors with one LED.
RGB, or red-green-blue, LEDs have three different color-emitting diodes that can be combined
to create all sorts of colors. In this circuit, you’ll learn how to use an RGB LED to create unique
color combinations. Depending on how bright each diode is, nearly any color is possible!

Parts Needed

You will need the following parts:

 Arduino Uno

 1x LED - RGB Common Cathode

 3x 330Ω Resistors

 5x Jumper Wires

 But which pin is which color? Pick up the RGB so that the longest pin (common ground)
is aligned to the left as shown in the graphic below. The pins are Red, Ground, Green,
and Blue – starting from the far left.
Circuit Diagram for Arduino

//Example sketch 03
const int RED_PIN = 9;
const int GREEN_PIN = 10;
const int BLUE_PIN = 11;

int DISPLAY_TIME = 10; // In milliseconds

void setup()
{

pinMode(RED_PIN, OUTPUT);
pinMode(GREEN_PIN, OUTPUT);
pinMode(BLUE_PIN, OUTPUT);
}

void loop()
{
mainColors();

showSpectrum();
}

void mainColors()
{
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, LOW);

delay(1000);

digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, LOW);

delay(1000);

digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, LOW);

delay(1000);

digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, HIGH);

delay(1000);

}
void showSpectrum()
{
int x; // define an integer variable called "x"

for (x = 0; x < 768; x++)

{
showRGB(x); // Call RGBspectrum() with our new x
delay(DISPLAY_TIME); // Delay for 10 ms (1/100th of a second)
}
}

void showRGB(int color)

{
int redIntensity;
int greenIntensity;
int blueIntensity;

if (color <= 255) // zone 1

{
redIntensity = 255 - color; // red goes from on to off
greenIntensity = color; // green goes from off to on
blueIntensity = 0; // blue is always off
}
else if (color <= 511) // zone 2
{
redIntensity = 0; // red is always off
greenIntensity = 255 - (color - 256); // green on to off
blueIntensity = (color - 256); // blue off to on
}
else // color >= 512 // zone 3
{
redIntensity = (color - 512); // red off to on
greenIntensity = 0; // green is always off
blueIntensity = 255 - (color - 512); // blue on to off
}

analogWrite(RED_PIN, redIntensity);
analogWrite(BLUE_PIN, blueIntensity);
analogWrite(GREEN_PIN, greenIntensity);
}
Experiment 4:

Create various lighting sequences by Connecting 8 LED

Introduction

Now that you’ve gotten your LED to blink on and off, it’s time to up the stakes a little bit
– by connecting eight LEDs at once. We’ll also give your Arduino R3 a little test by creating
various lighting sequences. This circuit is a great setup to start practicing writing your own
programs and getting a feel for the way Arduino works.

Circuit Diagram for Arduino

// Example sketch 04

int ledPins[] = {2,3,4,5,6,7,8,9};

void setup()

int index;
 for(index = 0; index <= 7; index++)

pinMode(ledPins[index],OUTPUT);

void loop()

//oneAfterAnotherNoLoop()

void oneAfterAnotherNoLoop()
{
int delayTime = 100; // time (milliseconds) to pause between LEDs

digitalWrite(ledPins[0], HIGH); //Turns on LED #0 (pin 2)

delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[1], HIGH); //Turns on LED #1 (pin 3)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[2], HIGH); //Turns on LED #2 (pin 4)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[3], HIGH); //Turns on LED #3 (pin 5)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[4], HIGH); //Turns on LED #4 (pin 6)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[5], HIGH); //Turns on LED #5 (pin 7)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[6], HIGH); //Turns on LED #6 (pin 8)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[7], HIGH); //Turns on LED #7 (pin 9)
delay(delayTime); //wait delayTime milliseconds
 digitalWrite(ledPins[7], LOW); //Turn off LED #7 (pin 9)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[6], LOW); //Turn off LED #6 (pin 8)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[5], LOW); //Turn off LED #5 (pin 7)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[4], LOW); //Turn off LED #4 (pin 6)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[3], LOW); //Turn off LED #3 (pin 5)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[2], LOW); //Turn off LED #2 (pin 4)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[1], LOW); //Turn off LED #1 (pin 3)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[0], LOW); //Turn off LED #0 (pin 2)
delay(delayTime); //wait delayTime milliseconds
}

4.2 One After Another Loop()

void oneAfterAnotherLoop()
{
int index;
int delayTime = 100; // milliseconds to pause between LEDs

for(index = 0; index <= 7; index++)

{
digitalWrite(ledPins[index], HIGH);
delay(delayTime);
}

for(index = 7; index >= 0; index--)

{
digitalWrite(ledPins[index], LOW);
delay(delayTime);
}
}
4.3 One On At A Time:

void oneOnAtATime()
{
int index;
int delayTime = 100; // milliseconds to pause between LEDs

for(index = 0; index <= 7; index++)

{
digitalWrite(ledPins[index], HIGH); // turn LED on
delay(delayTime); // pause to slow down
digitalWrite(ledPins[index], LOW); // turn LED off
}
}

4.4 Ping Pong()

void pingPong()
{
int index;
int delayTime = 100;

for(index = 0; index <= 7; index++)

{
digitalWrite(ledPins[index], HIGH); // turn LED on
delay(delayTime); // pause to slow down
digitalWrite(ledPins[index], LOW); // turn LED off
}

for(index = 7; index >= 0; index--)

{
digitalWrite(ledPins[index], HIGH); // turn LED on
delay(delayTime); // pause to slow down
digitalWrite(ledPins[index], LOW); // turn LED off
}
}
4.5 Marquee()

void marquee()
{
int index;
int delayTime = 200;

for(index = 0; index <= 3; index++) // Step from 0 to 3

{
digitalWrite(ledPins[index], HIGH); // Turn a LED on
digitalWrite(ledPins[index+4], HIGH); // Skip four, and turn that LED on
delay(delayTime); // Pause to slow down the sequence
digitalWrite(ledPins[index], LOW); // Turn the LED off
digitalWrite(ledPins[index+4], LOW); // Skip four, and turn that LED off
}
}

4.6 Random LED()

void randomLED()
{
int index;
int delayTime;

index = random(8); // pick a random number between 0 and 7

delayTime = 100;

digitalWrite(ledPins[index], HIGH); // turn LED on

delay(delayTime); // pause to slow down
digitalWrite(ledPins[index], LOW); // turn LED off
}
Experiment 5: Giving an input using push buttons

Introduction

Up until now, we’ve focused mostly on outputs. Now we’re going to go to the other end
of spectrum and play around with inputs. In experiment 2, we used an analog input to read the
potentiometer. In this circuit, we’ll be reading in one of the most common and simple inputs – a
push button – by using a digital input. The way a push button works with your Arduino Uno R3
is that when the button is pushed, the voltage goes LOW. Your Arduino Uno R3 reads this and
reacts accordingly.

In this circuit, you will also use a pull-up resistor, which keeps the voltage HIGH when
you’re not pressing the button.

Parts Needed

You will need the following parts:

 Arduino Uno

 1x LED

 1x 330Ω Resistor

 7x Jumper Wires

 2x Push Buttons

 2x 10k Resistors

Circuit Diagram for Arduino

// Example sketch 05

const int button1Pin = 4; // pushbutton 1 pin

const int button2Pin = 5; // pushbutton 2 pin
const int ledPin = 13; // LED pin

void setup()
{
pinMode(button1Pin, INPUT);
pinMode(button2Pin, INPUT);

pinMode(ledPin, OUTPUT);
}

void loop()
{
int button1State, button2State; // variables to hold the pushbutton states

button1State = digitalRead(button1Pin);
button2State = digitalRead(button2Pin);

if (((button1State == LOW) || (button2State == LOW)) // if we're pushing button 1 OR button 2

&& ! // AND we're NOT
((button1State == LOW) && (button2State == LOW)))
{
digitalWrite(ledPin, HIGH); // turn the LED on
}
else
{
 digitalWrite(ledPin, LOW); // turn the LED off
}

}
Experiment 6: Controlling the ON/OFF of an LED by Connecting photo resistor

Introduction

In experiment 2, you got to use a potentiometer, which varies resistance based on the
twisting of a knob. In this circuit, you’ll be using a photoresistor, which changes resistance based
on how much light the sensor receives. Since the Arduino Uno R3 can’t directly interpret
resistance (rather, it reads voltage), we need to use a voltage divider to use our photoresistor.
This voltage divider will output a high voltage when it is getting a lot of light and a low voltage
when little or no light is present.

Parts Needed

You will need the following parts:

 Arduino Uno

 1x LED

 1x 330Ω Resistor

 6x Jumper Wires

 1x Photoresistor

 1x 10k Resistor

Circuit Diagram for Arduino

//Example sketch 06

const int sensorPin = 0;

const int ledPin = 13;

int lightLevel, high = 0, low = 1023;

void setup()
{

pinMode(ledPin, OUTPUT);
}

void loop()
{

lightLevel = analogRead(sensorPin);

autoTune(); // have the Arduino do the work for us!

analogWrite(ledPin, lightLevel);

void manualTune()
{

lightLevel = map(lightLevel, 0, 1023, 0, 255);

lightLevel = constrain(lightLevel, 0, 255);

void autoTune()
{
 if (lightLevel < low)
{
low = lightLevel;
}

if (lightLevel > high)

{
high = lightLevel;
}

lightLevel = map(lightLevel, low+30, high-30, 0, 255);

lightLevel = constrain(lightLevel, 0, 255);

}
Experiment 7: Connecting temperature sensor and reading the output

Introduction

A temperature sensor is exactly what it sounds like – a sensor used to measure ambient
temperature. This particular sensor has three pins – a positive, a ground, and a signal. This is a
linear temperature sensor. A change in temperature of one degree centigrade is equal to a change
of 10 millivolts at the sensor output.

The TMP36 sensor has a nominal 750 mV at 25°C (about room temperature). In this
circuit, you’ll learn how to integrate the temperature sensor with your Arduino Uno R3, and use
the Arduino IDE’s serial monitor to display the temperature.

Parts Needed

You will need the following parts:

 Arduino Uno

 5x Jumper Wires

 1x Temperature Sensor
// Example sketch 07

const int temperaturePin = 0;

void setup()
{

Serial.begin(9600);

void loop()
{
float voltage, degreesC, degreesF;

voltage = getVoltage(temperaturePin);

degreesC = (voltage - 0.5) * 100.0;

degreesF = degreesC * (9.0/5.0) + 32.0;

Serial.print("voltage: ");
 Serial.print(voltage);
Serial.print(" deg C: ");
Serial.print(degreesC);
Serial.print(" deg F: ");
Serial.println(degreesF);

delay(1000); // repeat once per second (change as you wish!)

}

float getVoltage(int pin)

{

return (analogRead(pin) * 0.004882814);

}
Experiment 8: Using PWM to control and rotate a servo

Introduction

Servos are ideal for embedded electronics applications because they do one thing very
well that motors cannot – they can move to a position accurately. By varying the pulse width of
the output voltage to a servo, you can move a servo to a specific position. For example, a pulse
of 1.5 milliseconds will move the servo 90 degrees. In this circuit, you’ll learn how to use PWM
(pulse width modulation) to control and rotate a servo.

Parts Needed

You will need the following parts:

 1x Arduino Uno

 1x Servo

 8x Jumper Wires

Circuit Diagram for Arduino

// Example 8 Servo Motor
#include <Servo.h>

Servo myservo;

int pos = 0; // variable to store the servo position

void setup()
{
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop()
{
for(pos = 0; pos < 180; pos += 1) // goes from 0 degrees to 180 degrees
{ // in steps of 1 degree
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
for(pos = 180; pos>=1; pos-=1) // goes from 180 degrees to 0 degrees
{
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
}
Experiment 9: Using flex/force sensor to control and rotate a servo

Introduction

In this circuit, we will use a flex sensor to measure, well, flex! A flex sensor uses carbon
on a strip of plastic to act like a variable resistor, but instead of changing the resistance by
turning a knob, you change it by flexing (bending) the component. We use a “voltage divider”
again to detect this change in resistance.

The sensor bends in one direction and the more it bends, the higher the resistance gets; it has a
range from about 10K ohm to 35K ohm. In this circuit we will use the amount of bend of the flex
sensor to control the position of a servo.

Parts Needed

You will need the following parts:

 1x Arduino Uno

 1x Flex Sensor

 1x Servo

 1x 10k resistor

 11x Jumper Wires

Circuit Diagram for Arduino

// Example sketch 08

#include <Servo.h> // servo library

Servo servo1; // servo control object

void setup()
{

servo1.attach(9);
}

void loop()
{
int position;

servo1.write(90); // Tell servo to go to 90 degrees

delay(1000); // Pause to get it time to move

servo1.write(180); // Tell servo to go to 180 degrees

delay(1000); // Pause to get it time to move

servo1.write(0); // Tell servo to go to 0 degrees

delay(1000); // Pause to get it time to move

for(position = 0; position < 180; position += 2)

{
servo1.write(position); // Move to next position
delay(20); // Short pause to allow it to move
}

for(position = 180; position >= 0; position -= 1)

{
servo1.write(position); // Move to next position
delay(20); // Short pause to allow it to move
 }
}

// Example sketch 09b

#include <Servo.h>

Servo servo1;

const int flexpin = 0;

void setup()
{

Serial.begin(9600);

servo1.attach(9);
}

void loop()
{
int flexposition; // Input value from the analog pin.
int servoposition; // Output value to the servo.

flexposition = analogRead(flexpin);

servoposition = map(flexposition, 750, 850, 0, 180);

servoposition = constrain(servoposition, 0, 180);

servo1.write(servoposition);

Serial.print("sensor: ");
Serial.print(flexposition);
Serial.print(" servo: ");
Serial.println(servoposition);

delay(500); // wait 20ms between servo updates

}
Experiment 10: Using soft potentiometer to control RGB LED

Introduction

In this circuit, we are going to use yet another kind of variable resistor – this time, a soft
potentiometer (or soft pot). This is a thin and flexible strip that can detect where pressure is being
applied. By pressing down on various parts of the strip, you can vary the resistance from 100 to
10k ohms. You can use this ability to track movement on the soft pot, or simply as a button. In
this circuit, we’ll get the soft pot up and running to control an RGB LED.

Parts Needed

You will need the following parts:

 1x Arduino Uno

 1x Soft Potentiometer

 1x 10k resistor

 3x 330Ω resistors

 1x RGB LED

 9x Jumper Wires

Circuit Diagram for Arduino

// Example sketch 10
const int RED_LED_PIN = 9; // Red LED Pin
const int GREEN_LED_PIN = 10; // Green LED Pin
const int BLUE_LED_PIN = 11; // Blue LED Pin

const int SENSOR_PIN = 0; // Analog input pin

int redValue, greenValue, blueValue;

void setup()
{

void loop()
{
int sensorValue;

sensorValue = analogRead(SENSOR_PIN);

setRGB(sensorValue);
}

void setRGB(int RGBposition)

{
int mapRGB1, mapRGB2, constrained1, constrained2;

mapRGB1 = map(RGBposition, 0, 341, 255, 0);

constrained1 = constrain(mapRGB1, 0, 255);

mapRGB2 = map(RGBposition, 682, 1023, 0, 255);

constrained2 = constrain(mapRGB2, 0, 255);

redValue = constrained1 + constrained2;

greenValue = constrain(map(RGBposition, 0, 341, 0, 255), 0, 255)

- constrain(map(RGBposition, 341, 682, 0,255), 0, 255);

blueValue = constrain(map(RGBposition, 341, 682, 0, 255), 0, 255)

- constrain(map(RGBposition, 682, 1023, 0, 255), 0, 255);

analogWrite(RED_LED_PIN, redValue);
analogWrite(GREEN_LED_PIN, greenValue);
 analogWrite(BLUE_LED_PIN, blueValue);

}
Experiment 11: Switching ON/OFF a piezoelectric buzzer

Introduction

In this circuit, we’ll again bridge the gap between the digital world and the analog world.
We’ll be using a piezo buzzer that makes a small “click” when you apply voltage to it (try it!).
By itself that isn’t terribly exciting, but if you turn the voltage on and off hundreds of times a
second, the piezo buzzer will produce a tone. And if you string a bunch of tones together, you’ve
got music! This circuit and sketch will play a classic tune. We’ll never let you down!

Parts Needed

You will need the following parts:

 1x Arduino Uno

 1x Piezo Buzzer

 3x Jumper Wires

Circuit Diagram for Arduino

// Example sketch 11

const int buzzerPin = 9;

const int songLength = 18;

char notes[] = "cdfda ag cdfdg gf "; // a space represents a rest

int beats[] = {1,2,1,2,1,1,4,4,2,1,1,1,1,1,1,4,4,2};

int tempo = 113;

void setup()
{
pinMode(buzzerPin, OUTPUT);
}

void loop()
{
int i, duration;

for (i = 0; i < songLength; i++) // step through the song arrays

{
duration = beats[i] * tempo; // length of note/rest in ms

if (notes[i] == ' ') // is this a rest?

{
delay(duration); // then pause for a moment
}
else // otherwise, play the note
{
tone(buzzerPin, frequency(notes[i]), duration);
delay(duration); // wait for tone to finish
}
delay(tempo/10); // brief pause between notes
}

while(true){}

int frequency(char note)

{

int i;
 const int numNotes = 8; // number of notes we're storing

char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
int frequencies[] = {262, 294, 330, 349, 392, 440, 494, 523};

for (i = 0; i < numNotes; i++) // Step through the notes

{
if (names[i] == note) // Is this the one?
{
return(frequencies[i]); // Yes! Return the frequency
}
}
return(0); // We looked through everything and didn't find it,
// but we still need to return a value, so return 0.
}
Experiment 12: Control spinning of motor

Introduction

Back in experiment 8, you got to work with a servo motor. Now, we are going to tackle
spinning a motor. This requires the use of a transistor, which can switch a larger amount of
current than the Arduino Uno R3 can.

When using a transistor, you just need to make sure its maximum specs are high enough
for your use case. The transistor we are using for this circuit is rated at 40V max and 200
milliamps max – perfect for our toy motor! When the motor is spinning and suddenly turned off,
the magnetic field inside it collapses, generating a voltage spike. This can damage the transistor.
To prevent this, we use a “flyback diode”, which diverts the voltage spike around the transistor.

Parts Needed

You will need the following parts:

 1x Arduino Uno

 1x Motor

 1x 330Ω Resistor

 1x NPN transistor

 1x Diode 1N4148

 6x Jumper Wires

Circuit Diagram for Arduino

// Example sketch 12

const int motorPin = 9;

void setup()
{

pinMode(motorPin, OUTPUT);

Serial.begin(9600);
}

void loop()
{
serialSpeed();
}

void motorOnThenOff()
{
int onTime = 3000; // milliseconds to turn the motor on
int offTime = 3000; // milliseconds to turn the motor off

digitalWrite(motorPin, HIGH); // turn the motor on (full speed)

delay(onTime); // delay for onTime milliseconds
digitalWrite(motorPin, LOW); // turn the motor off
delay(offTime); // delay for offTime milliseconds
}

void motorOnThenOffWithSpeed()
{
int Speed1 = 200; // between 0 (stopped) and 255 (full speed)
int Time1 = 3000; // milliseconds for speed 1

int Speed2 = 50; // between 0 (stopped) and 255 (full speed)

int Time2 = 3000; // milliseconds to turn the motor off

analogWrite(motorPin, Speed1); // turns the motor On

delay(Time1); // delay for onTime milliseconds
analogWrite(motorPin, Speed2); // turns the motor Off
delay(Time2); // delay for offTime milliseconds
}
void motorAcceleration()
{
int speed;
int delayTime = 20; // milliseconds between each speed step

for(speed = 0; speed <= 255; speed++)

{
analogWrite(motorPin,speed); // set the new speed
delay(delayTime); // delay between speed steps
}

for(speed = 255; speed >= 0; speed--)

{
analogWrite(motorPin,speed); // set the new speed
delay(delayTime); // delay between speed steps
}
}

void serialSpeed()
{
int speed;

Serial.println("Type a speed (0-255) into the box above,");

Serial.println("then click [send] or press [return]");
Serial.println(); // Print a blank line

while(true) // "true" is always true, so this will loop forever.

{

while (Serial.available() > 0)

{

speed = Serial.parseInt();

speed = constrain(speed, 0, 255);

Serial.print("Setting speed to ");

Serial.println(speed);

analogWrite(motorPin, speed);
}
 }
}
Experiment 13: Control ON/OFF of a relay
Introduction
In this circuit, we are going to use some of the lessons we learned in experiment 12 to
control a relay. A relay is basically an electrically controlled mechanical switch. Inside that
harmless looking plastic box is an electromagnet that, when it gets a jolt of energy, causes a
switch to trip. In this circuit, you’ll learn how to control a relay like a pro – giving your Arduino
even more powerful abilities!

Parts Needed

You will need the following parts:

 1x Arduino Uno

 2x LEDs

 2x 330Ω Resistors

 1x Relay (SPDT)

 1x Diode 1N4148

 1x NPN Transistor

 14x Jumper Wires

Circuit Diagram for Arduino

// Example 13

int relay = 13;

void setup() {

pinMode(relay, OUTPUT);
}

void loop() {
digitalWrite(relay, HIGH); // turn the relay on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(relay, LOW); // turn the relay off by making the voltage LOW
delay(1000); // wait for a second
}
Experiment 14: Using a shift register to control eight LEDs

Introduction

Now we are going to step into the world of ICs (integrated circuits). In this circuit, you’ll
learn all about using a shift register (also called a serial-to-parallel converter). The shift register
will give your RedBoard or Arduino Uno R3 an additional eight outputs, using only three pins on
your board. For this circuit, you’ll practice by using the shift register to control eight LEDs.

Parts Needed

You will need the following parts:

 1x Arduino Uno

 8x LEDs

 8x 330Ω Resistors

 1x Shift Register 8-Bit - 74HC595

 19x Jumper Wires

Circuit Diagram for Arduino

int datapin = 2;
int clockpin = 3;
int latchpin = 4;

byte data = 0;

void setup()
{

pinMode(datapin, OUTPUT);
pinMode(clockpin, OUTPUT);
pinMode(latchpin, OUTPUT);
}

void loop()
{

oneAfterAnother(); // All on, all off

void shiftWrite(int desiredPin, boolean desiredState)

bitWrite(data,desiredPin,desiredState);

shiftOut(datapin, clockpin, MSBFIRST, data);

digitalWrite(latchpin, HIGH);
digitalWrite(latchpin, LOW);
}

void oneAfterAnother()
{
int index;
int delayTime = 100; // Time (milliseconds) to pause between LEDs
// Make this smaller for faster switching
 for(index = 0; index <= 7; index++)
{
shiftWrite(index, HIGH);
delay(delayTime);
}

for(index = 7; index >= 0; index--)

{
shiftWrite(index, LOW);
delay(delayTime);
}
}

void oneOnAtATime()
{
int index;
int delayTime = 100; // Time (milliseconds) to pause between LEDs

for(index = 0; index <= 7; index++)

{
shiftWrite(index, HIGH); // turn LED on
delay(delayTime); // pause to slow down the sequence
shiftWrite(index, LOW); // turn LED off
}
}

void pingPong()
{
int index;
int delayTime = 100; // time (milliseconds) to pause between LEDs
// make this smaller for faster switching

for(index = 0; index <= 7; index++)

{
shiftWrite(index, HIGH); // turn LED on
delay(delayTime); // pause to slow down the sequence
shiftWrite(index, LOW); // turn LED off
}

for(index = 7; index >= 0; index--)

{
shiftWrite(index, HIGH); // turn LED on
 delay(delayTime); // pause to slow down the sequence
shiftWrite(index, LOW); // turn LED off
}
}

void randomLED()
{
int index;
int delayTime = 100; // time (milliseconds) to pause between LEDs
// make this smaller for faster switching

index = random(8); // pick a random number between 0 and 7

shiftWrite(index, HIGH); // turn LED on

delay(delayTime); // pause to slow down the sequence
shiftWrite(index, LOW); // turn LED off
}

void marquee()
{
int index;
int delayTime = 200; // Time (milliseconds) to pause between LEDs

for(index = 0; index <= 3; index++)

{
shiftWrite(index, HIGH); // Turn a LED on
shiftWrite(index+4, HIGH); // Skip four, and turn that LED on
delay(delayTime); // Pause to slow down the sequence
shiftWrite(index, LOW); // Turn both LEDs off
shiftWrite(index+4, LOW);
}
}

void binaryCount()
{
int delayTime = 1000; // time (milliseconds) to pause between LEDs

shiftOut(datapin, clockpin, MSBFIRST, data);

digitalWrite(latchpin, HIGH);
 digitalWrite(latchpin, LOW);

data++;

delay(delayTime);
}
15. Using ultrasonic sensor module to activate buzzer:

Parts Needed

You will need the following parts:

 Arduino UNO R3

 One (1) HC-SR04 Ultrasonic Sensor

 One (1) Red LED

 One (1) Green LED

 Two (2) 560 ohm (Green, Blue, Brown, Gold) Resistors

 Half Breadboard

 Eight (8) Male/Male hookup wires

 A ruler that measures centimeters (or use the serial monitor)

#define trigPin 13
#define echoPin 12
#define led 11
#define led2 10

void setup() {
Serial.begin (9600);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(led, OUTPUT);
pinMode(led2, OUTPUT);
}

void loop() {
long duration, distance;
digitalWrite(trigPin, LOW); // Added this line
delayMicroseconds(2); // Added this line
digitalWrite(trigPin, HIGH);

delayMicroseconds(10); // Added this line

digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
distance = (duration/2) / 29.1;
if (distance < 4) { // This is where the LED On/Off happens
digitalWrite(led,HIGH); // When the Red condition is met, the Green LED should turn off
digitalWrite(led2,LOW);
}
else {
digitalWrite(led,LOW);
digitalWrite(led2,HIGH);
}
if (distance >= 200 || distance <= 0){
Serial.println("Out of range");
}
else {
Serial.print(distance);
Serial.println(" cm");
}
delay(500);
}
16. Using pressure sensor module to activate relay

In this tutorial you will learn how to use an FSR - Force Sensitive Resistor with Arduino
to fade an LED. This sensor is a variable resistor just like a photocell or flex sensor. The
resistance changes by applying pressure on it.

Let's get started!

 Arduino uno

 Breadboard

 Force sensitive resistor

 LED

 10KOhm & 220 Ohm resistors

const int ledPin = 3; //pin 3 has PWM funtion

const int sensorPin = A0; //pin A0 to read analog input

int value; //save analog value

void setup(){

pinMode(ledPin, OUTPUT); //Set pin 3 as 'output'

 Serial.begin(9600); //Begin serial communication

void loop(){

value = analogRead(sensorPin); //Read and save analog value from potentiometer

Serial.println(value); //Print value
value = map(value, 0, 1023, 0, 255); //Map value 0-1023 to 0-255 (PWM)
analogWrite(ledPin, value); //Send PWM value to led
delay(100); //Small delay

}
17. Detecting vibration and knocks using sound and piezomodule

 Arduino uno

 Breadboard (or breadboard shield)

 Buzzer

 Vibration/shake sensor

The connections are pretty easy, see the above image with the breadboard circuit schematic.

 Connect one pin of vibration sensor to Arduino Analog pin A0 and the other to 5V pin.

 Now connect the buzzer, one pin to Arduino pin 8 and the other to GND.

const int buzzer = 8; //Buzzer connected to pin 8 of Arduino uno / mega

int sensor; //Variable to store analog value (0-1023)

void setup()
{
Serial.begin(9600); //Only for debugging
pinMode(buzzer, OUTPUT);
}
void loop()
{
sensor = analogRead(A0);
//While sensor is not moving, analog pin receive 1023~1024 value
if (sensor<1022){
tone(buzzer, 500);
Serial.print("Sensor Value: ");
Serial.println(sensor);
}
 else{
noTone(buzzer);
Serial.print("Sensor Value: ");
Serial.println(sensor);
}

delay(100); //Small delay

}
18. Build an Intelligent system Using accelerometer

As the datasheet says, ADXL335 is a small, thin, low power, complete 3-axis accelero-meter
with signal conditioned voltage outputs. The product measures acceleration with a minimum
full-scale range of ±3 g. It can measure the static acceleration of gravity in tilt-sensing
applications, as well as dynamic acceleration resulting from motion, shock, or vibration. 
ADXL335 is 3v3 compatible device, it's powered by a 3.3v source and also generates 3.3v peak
outputs. It has three outputs for each axis i.e. X, Y & Z. These are analog outputs and thus
require an ADC in a micro-controller. Arduino solves this problem. We will be using the analog
functions of Arduino.

Step 1: Parts Required

1. Arduino-Any Arduino/clone will do but I have used Freeduino v1.16

2. ADXL335 accelerometer

3. Connecting wires(Relimates)

4. USB cable for connecting Arduino with your Laptop

The accelerometer module has 5 pins, namely

1. GND-To be connected to Arduino's GND

2. VCC-To be connected to Arduino's 5V

3. X-To be connected to Analog Pin A5

4. Y-To be connected to Analog Pin A4

5. Z-To be connected to Analog Pin A3

//connect 3.3v to AREF

const int ap1 = A5;
const int ap2 = A4;
const int ap3 = A3;

int sv1 = 0;
int ov1 = 0;
int sv2 = 0;
int ov2= 0;
int sv3 = 0;
int ov3= 0;
void setup() {
// initialize serial communications at 9600 bps:
Serial.begin(9600);

void loop() {
analogReference(EXTERNAL); //connect 3.3v to AREF
// read the analog in value:
sv1 = analogRead(ap1);
// map it to the range of the analog out:
ov1 = map(sv1, 0, 1023, 0, 255);
// change the analog out value:
delay(2);
//
sv2 = analogRead(ap2);

ov2 = map(sv2, 0, 1023, 0, 255);

//
delay(2);
//
sv3 = analogRead(ap3);

ov3 = map(sv3, 0, 1023, 0, 255);

// print the results to the serial monitor:

Serial.print("Xsensor1 = " );
Serial.print(sv1);
Serial.print("\t output1 = ");
Serial.println(ov1);

Serial.print("Ysensor2 = " );
Serial.print(sv2);
Serial.print("\t output2 = ");
Serial.println(ov2);

Serial.print("Zsensor3 = " );
Serial.print(sv3);
Serial.print("\t output3 = ");
Serial.println(ov3);
 delay(3000);