This document provides an overview of the Arduino microcontroller board. It begins with an abstract discussing the advantages of Arduino boards over other controller boards. It then introduces Arduino, describing it as an open-source physical computing platform using a simple I/O board and development environment. The remainder of the document details the hardware components of the Arduino board, the Arduino programming software, and concepts for programming Arduino including variables, data types, and control structures.

1. ARDUINO
(EASY WAY TO OUR PROJECTS)
NAGA SAI ORUGANTI
3rd year, B.Tech
Electronics and Communication Engineering
Mail id: - onagasai547@gmail.com
Ph.no:- 7661919861
Krishna Chaitanya Institute of Technology and
Sciences,
Markapur.
BIJIVEMULA VIKRAM KUMAR REDDY
3rd year, B.Tech
Electronics and Communication Engineering
Mail id: - bijivemulavikram466@gmail.com
Ph.no:- 9550223266
Krishna Chaitanya Institute of Technology and
Sciences,
Markapur.
Abstract:-
In the days of controller’s world, many boards came into existence and supported to
many applications for the people in home appliances, gaming tools etc., though they have
many advantages, there is also some disadvantages. The programming and the connections
of controller’s is cumbersome. In many real time applications, cost of the components with
these controller’s is too heavy.
To avoid these, a controller board was introduced in early 21st (in the year of 2008)
century, that is ARDUINO microcontroller based board. It is a single-board
microcontroller and a software suite for programming. The hardware consists of a simple
open hardware design for the controller with an Atmel AVR processor and on-board I/O
support. The software consists of a standard programming language and the boot loader
that runs on the board. The following pages have will explain ARDUINO in detail.
Introduction:-
Most of us know what a computer
looks like. It usually has a keyboard, monitor,
CPU (Central Processing Unit), printer, and a
mouse. These types of computers, like the Mac
or PC, are primarily designed to communicate
(or "interface") with humans. Database
Management, financial analysis, or even word-
processing are all accomplished inside the
"Big box" that contains the CPU, memory,
hard drive, etc.
If we think about it, the whole purpose
of a monitor, keyboard, mouse, & even the
printer is to "connect" the CPU to the outside
world. We call these devices
“microcontrollers". Micro because they're
small and controller because they "control"
machines, gadgets, whatever. Microcontrollers
by definition they are designed to connect to
machines, rather than people. They're cool
because, you can build a machine or
instrument, write programs to control it and
then let it work for you automatically. There
are an infinite number of applications for
microcontrollers. Hundreds of different
variations of microcontrollers are available.
Some are programmed once &
produced for specific applications, such as
controlling your printer. Others are "re-
programmable", which means they can be used
over and over for different applications.
Microcontroller:-
A Microcontroller is a Microcomputer
in a single Chip. That means that a
microcontroller chip includes a microprocessor
(CPU) as well as some often used peripherals.
A controller is used to control some process or
aspect of the environment.
As the process of miniaturization
continued, all of the components needed for a
controller were built right onto one chip The

2. microcontroller could be called a "one-chip
solution". It typically includes:
• CPU (central processing unit or the
microprocessor)
• EPROM/PROM/ROM (Read Only
Memory for the program code)
• RAM (Random Access Memory for
the data)
• I/O (input/output) devices (serial,
parallel, ADC, DAC etc.)
• Timers
• Interrupt controller
Arduino Board:-
Arduino is an open source physical
computing platform based on a simple
input/output (I/O) board and a development
environment that implements the Processing
Language. Figure 1 shows our Arduino board.
Fig -1
Power Supply:-
Directly below the USB connector is
the 5V voltage regulator. This regulates
whatever voltage (between 7 and 12 volts) is
supplied from the power socket into a constant
5V. 5V (along with 3V, 6V, 9V, and 12V) is a
bit of a standard voltage in electronics. 3, 6,
and 9V are standard because the voltage that
you get from a single alkaline cell is 1.5V, and
these are all convenient multiples of 1.5V,
which is what you get when you make a
“battery” of two, three, six, or eight cells. So if
that is the case, you might be wondering why
5V? You cannot make that using 1.5V cells.
Well, the answer lies in the fact that in the
early days of computing, a range of chips
became available, each of which contained
logic gates. These chips used something called
TTL (Transistor-Transistor Logic), which was
a bit
fussy about its voltage requirements and
required something between 4.5V and 5.5V.
So 5V became the standard voltage for all
digital electronics. These days, the type of
logic gates used in chips has changed and they
are far more tolerant of different voltages. The
5V voltage regulator chip is actually quite big
for a surface-mount component. This is so that
it can dissipate the heat required to regulate the
voltage at a reasonably high current, which is
useful when driving our external electronics.
Analog Inputs:-
The next section of connections is
labeled Analog In 0 to 5. These six pins can be
used to measure the voltage connected to them
so that the value can be used in a sketch. Note
that they measure a voltage and not a current.
Only a tiny current will ever flow into them
and down to ground because they have a very
large internal resistance. Although labelled as
analog inputs, these connections can also be
used as digital inputs or outputs, but by
default, they are analog inputs.
Fig -2
Digital Connections:-
We now switch to the top connector
and start on the right side. We have pins
labelled Digital 0 to 13. These can be used as
either inputs or outputs. When using them as
outputs, they behave rather like the supply
voltages we talked about earlier, except that
these are all 5V and can be turned on or off
from our sketch. So, if we turn them on from
our sketch, they will be at 5V and if we turn
them off, they will be at 0V. As with the
supply connectors, we have to be careful not to
exceed their maximum current capabilities.

3. Fig -3
Microcontroller:-
Getting back to our tour of the Arduino
board, the microcontroller chip itself is the
black rectangular device with 28 pins. This is
fitted into a DIL (dual in-line) socket so that it
can be easily replaced. The 28-pin
microcontroller chip used on Arduino is the
ATmega328. Figure 2-4 is a block diagram
showing the main features of this device. The
heart, or perhaps more appropriately the brain,
of the device is the CPU (central processing
unit). It controls everything that goes on within
the device. It fetches program instructions
stored in the Flash memory and executes them.
This might involve fetching data from working
memory (RAM), changing it, and then putting
it back. Or, it may mean changing one of the
digital outputs from 0 to 5 volts. The
electrically erasable programmable read only
memory (EEPROM) is a little like the Flash
memory in that and is nonvolatile. That is, you
can turn the device off and on and it will not
have forgotten what is in the EEPROM.
Whereas the Flash memory is intended for
storing program instructions (from sketches),
the EEPROM is used to store data that you do
not want to lose in the event of a reset or
power failure.
Fig-5.ATmega328 block diagram
Other Components:-
Above the microcontroller there is a
small, silver, rectangular component. This is a
quartz crystal oscillator. It “ticks” 16 million
times a second, and on each of those ticks, the
microcontroller can perform one operation—
an addition, subtraction, etc. To the right of the
crystal, is the Reset switch. Clicking this sends
a logic pulse to the Reset pin of the
microcontroller, causing the microcontroller to
start its program afresh and clear its memory.
Note that any program stored on the device
will be retained because this is kept in
nonvolatile Flash memory—that is, memory
that remembers even when the device is not
powered. To the left of the Reset button is the
serial programming connector. It offers
another means of programming the Arduino
without using the USB port. Since we do have
a USB connection and software that makes it
convenient to use, we will not avail ourselves
of this feature. In the top left of the board next
to the USB socket is the USB interface chip.
This converts the signal levels used by the

4. USB standard to levels that can be used
directly by the Arduino board.
Fig-6
The Software (IDE):-
The IDE (Integrated Development
Environment) is a special program running on
the computers that allows to write sketches for
the Arduino board in a simple language
modeled after the Processing language. The
magic happens when the upload button is
pressed, that uploads the sketch to the board,
the code that written is translated into the C,
and is passed to the avr-gcc compiler, an
important piece of open source software that
makes the final translation into the language
understood by the microcontroller. This last
step is quite important, because it's where
Arduino makes your life simple by hiding
away as much as possible of the complexities
of programming microcontrollers. The
programming cycle on Arduino is basically as
follows:
• Plug your board into a USB port on
your computer.
• Write a sketch that will bring the board
to life.
• Upload this sketch to the board through
the USB connection and wait a couple of
seconds for the board to restart.
• The board executes the sketch that you
wrote.
Software description is given below.
Structure:-
An Arduino sketch runs in two parts:
void setup():-
This is where you place the
initialisation code—the instructions that set up
the board before the main loop of the sketch
starts.
void loop():-
This contains the main code of your
sketch. It contains a set of instructions that get
repeated over and over until the board is
switched off.
Special symbols:-
Arduino includes a number of symbols
to delineate lines of code, comments, and
blocks of code.
; (semicolon):-
Every instruction (line of code) is
terminated by a semicolon. This syntax lets
you format the code freely. You could even
put two instructions on the same line, as long
as you separate them with a semicolon.
(However, this would make the code harder to
read.)
{} (curly braces):-
This is used to mark blocks of code.
For example, when you write code for the
loop() function, you have to use curly braces
before and after the code.
Comments:-
These are portions of text ignored by
the Arduino processor, but are extremely
useful to remind yourself (or others) of what a
piece of code does.
There are two styles of comments in Arduino:
// single-line: this text is ignored until the
end of the line. /* multiple-line: you can write
a whole poem in here */
Constants:-
Arduino includes a set of predefined
keywords with special values. HIGH and
LOW are used, for example, when you want to
turn on or off an Arduino pin. INPUT and
OUTPUT are used to set a specific pin to be
either an input or an output true and false
indicate exactly what their names suggest: the
truth or falsehood of a condition or expression.
Variables:-
Variables are named areas of the
Arduino's memory where you can store data
that you can use and manipulate in your
sketch. As the name suggests, they can be
changed as many times as you like. Because
Arduino is a very simple processor, when you
declare a variable you have to specify its type.
This means telling the processor the size of the
value you want to store.

5. Data types:-
Boolean:-
Can have one of two values: true or
false.
Char:-
Holds a single character, such as A.
Like any computer, Arduino stores it as a
number, even though you see text. When chars
are used to store numbers, they can hold
values from –128 to 127.
Byte:-
Holds a number between 0 and 255. As
with chars, bytes use only one byte of
memory.
Int:-
Uses 2 bytes of memory to represent a
number between –32,768 and 32,767; it's the
most common data type used in Arduino.
unsigned int:-
Like int, uses 2 bytes but the unsigned
prefix means that it can't store negative
numbers, so its range goes from 0 to 65,535.
Long:-
This is twice the size of an int and
holds numbers from –2,147,483,648 to
2,147,483,647.
unsigned long:-
Unsigned version of long; it goes from
0 to 4,294,967,295.
Float:-
It is quite big and can hold floating-
point values, a fancy way of saying that you
can use it to store numbers with a decimal
point in it. It will eat up 4 bytes of your
precious RAM and the functions that can
handle them use up a lot of code memory as
well. So use floats sparingly.
Double:-
Double-precision floating-point
number, with a maximum value of
1.7976931348623157 x 10308. Wow, that's
huge!
String:-
A set of ASCII characters that are used
to store textual information (you might use a
string to send a message via a serial port, or to
display on an LCD display). For storage, they
use one byte for each character in the string,
plus a null character to tell Arduino that it's the
end of the string. The following are equivalent:
char string1[] = "Arduino"; // 7 chars +
1 null char
char string2[8] = "Arduino"; // Same as
above
Array:-
A list of variables that can be accessed
via an index. They are used to build tables of
values that can easily be accessed. For
example, if you want to store different levels
of brightness to be used when fading an LED,
you could create six variables called light01,
light02, and so
on. Better yet, you could use a simple array
like:
int light[6] = {0, 20, 50, 75, 100};
The word "array" is not actually used in
the variable
declaration: the symbols [] and {} do
the job.
Control Structures:-
Arduino includes keywords for
controlling the logical flow of your sketch.
if … else:-
This structure makes decisions in your
program. if must be followed by a question
specified as an expression contained in
parentheses. If the expression is true, whatever
follows will be executed. If it's false, the block
of code following else will be executed. It's
possible to use just if without providing an else
clause.
Example:
if (val == 1) {
digitalWrite(LED,HIGH);
}
for
Lets you repeat a block of code a
specified number of
times.
Example:
for (int i = 0; i < 10; i++) {
Serial.print("ciao");
}
switch case:-
The if statement is like a fork in the road
for your program. switch case is like a massive
roundabout. It lets your program take a variety
of directions depending on the value of a
variable. It's quite useful to keep your code
tidy as it replaces long lists of if statements.
Example:
switch (sensorValue) {
case 23:
digitalWrite(13,HIGH);

6. break;
case 46:
digitalWrite(12,HIGH);
break;
default: // if nothing matches this is
executed
digitalWrite(12,LOW);
digitalWrite(13,LOW);
}
While:-
Similar to if, this executes a block of
code while a certain condition is true.
Example:
// blink LED while sensor is below 512
sensorValue = analogRead(1);
while (sensorValue < 512) {
digitalWrite(13,HIGH);
delay(100);
digitalWrite(13,HIGH);
delay(100);
sensorValue = analogRead(1);
}
do … while:-
Just like while, except that the code is
run just before the the condition is evaluated.
This structure is used when you want the code
inside your block to run at least once before
you check the condition.
Example:
do {
digitalWrite(13,HIGH);
delay(100);
digitalWrite(13,HIGH);
delay(100);
sensorValue = analogRead(1);
} while (sensorValue < 512);
Break:-
This term lets you leave a loop and
continue the execution of the code that appears
after the loop. It's also used to separate the
different sections of a switch case statement.
Example:
// blink LED while sensor is below 512
do {
// Leaves the loop if a button is pressed
if (digitalRead(7) == HIGH)
break;
digitalWrite(13,HIGH);
delay(100);
digitalWrite(13,HIGH);
delay(100);
sensorValue = analogRead(1);
} while (sensorValue < 512);
Sensors and Actuators:-
Sensors and actuators are electronic
components that allow a piece of electronics to
interact with the world. As the microcontroller
is a very simple computer, it can process only
electric signals (a bit like the electric pulses
that are sent between neurons in our brains).
For it to sense light, temperature, or other
physical quantities, it needs something that can
convert them into electricity. In our body, for
example, the eye converts light into signals
that get sent to the brain using nerves. In
electronics, we can use a simple device called
a light-dependent resistor (an LDR or
photoresistor) that can measure the amount of
light that hits it and report it as a signal that
can be understood by the microcontroller.
Once the sensors have been read, the device
has the information needed to decide how to
react. The decision-making process is handled
by the microcontroller, and the reaction is
performed by actuators.
In our bodies, for example, muscles
receive electric signals from the brain and
convert them into a movement. In the
electronic world, these functions could
be performed by a light or an electric motor.
In the following sections, you will learn how
to read sensors of different types and control
different kinds of 20actuators.
Arduino Software icons:-
Fig-7: application

7. Fig-8: main starting window of arduino
Fig-9: Workspace window of arduino
Applications:-
Arduino is used in wide range of
applications. These are used due to the easy
programming capabilities, simplifies the
connections of the peripherals, low cost, space
occupying is low. Arduino’s are mainly used
in
 Robots manufacturing,
 RFID control systems,
 Automatic controls,
 Multicolor Light Display,
Summary:-
Arduino use ATmega328
microcontroller which performs specific
instruction as per user’s desire. It consists of
Quartz Crystal Oscillator, Reset button, DIL
socket, USB connector, Power supply socket,
Digital I/O pins, Analog inputs pins. The
language used in software development is
similar with C language. With the help of the
Arduino a user can develop many applications.
Acknowledgement:-
We sincerely thank to our HOD sri Dr
ANNA RANGANAYAKULU for his
encouragement. We are especially thankful to
our faculty and friends for their support.
Bibliography:-
1. Beginning Arduino Copyright © 2010
by Michael McRoberts.
2. Arduino Cookbook by Mc Robert.
3. https://www.arduino.cc/en/Main/Ardui
noBoardUno
4. https://www.arduino.cc/en/Main/Softw
are
5. https://en.wikipedia.org/wiki/Arduino
6. "Arduino - Introduction". arduino.cc.
7. "How many Arduinos are "in the
wild?" About 300,000". Adafruit
Industries. May 15, 2011.
Retrieved 2013-05-26.
8. "Arduino FAQ – With David
Cuartielles". Malmö University. April
5, 2013. Retrieved2014-03-24.
9. David Kushner (26 Oct 2011). "The
Making of Arduino". IEEE Spectrum.
10. Allan, Alasdair (6 March
2015). "Arduino Wars: Group Splits,
Competing Products
Revealed?". makezine.com. Maker
Media, Inc. Retrieved 21 April 2015.
11. Banzi, Massimo (19 March
2015). "Massimo Banzi: Fighting for
Arduino".makezine.com. Maker
Media, Inc. Retrieved 21 April 2015.
12. Williams, Elliot (28 March
2015). "Arduino SRL to Distributors:
“We’re the REAL
Arduino”". Hackaday.com.
Hackaday.com. Retrieved 21
April 2015.
13. "Arduino Announces New Brand,
Genuino, Manufacturing Partnership
with Adafruit - Make:". Make:.
Retrieved 17 May 2015.