unit II : IOT BOARDS : A: Arduino

Arduino
Introduction to Arduino Programming-
 features of arduino,
 Arduino IDE,
 sketch,
 sketch structure,
 supported data types,
 Arduino function libraries,
 operators,
 control statements,
 arrays,
 String functions,
 Interrupts,
 sensor interface with Arduino,
 DHT sensor library,
 types of motor actuators,
 Arduino servo library

Introduction to Arduino Programming:

Arduino is an open-source electronics platform based on easy-to-use hardware
and software. It's intended for anyone making interactive projects.

What is Arduino?
Arduino is an open-source electronics platform based on easy-to-use hardware and
software. Arduino boards are able to read inputs - light on a sensor, a finger on a
button, or a Twitter message - and turn it into an output - activating a motor,
turning on an LED, publishing something online. You can tell your board what to
do by sending a set of instructions to the microcontroller on the board. To do so
you use the Arduino programming language (based on Wiring), and the Arduino
Software (IDE), based on Processing.

Over the years Arduino has been the brain of thousands of projects, from everyday
objects to complex scientific instruments. A worldwide community of makers -
students, hobbyists, artists, programmers, and professionals - has gathered around
this open-source platform, their contributions have added up to an incredible
amount of accessible knowledge that can be of great help to novices and experts
alike.

Why Arduino?
Thanks to its simple and accessible user experience, Arduino has been used in
thousands of different projects and applications. The Arduino software is easy-to-
use for beginners, yet flexible enough for advanced users. It runs on Mac,
Windows, and Linux. Teachers and students use it to build low cost scientific
instruments, to prove chemistry and physics principles, or to get started with
programming and robotics. Designers and architects build interactive prototypes,
musicians and artists use it for installations and to experiment with new musical
instruments. Makers, of course, use it to build many of the projects exhibited at the
Maker Faire, for example. Arduino is a key tool to learn new things. Anyone -
children, hobbyists, artists, programmers - can start tinkering just following the
step by step instructions of a kit, or sharing ideas online with other members of the
Arduino community.

Advantages:

Inexpensive - Arduino boards are relatively inexpensive compared to other

microcontroller platforms. The least expensive version of the Arduino module can
be assembled by hand, and even the pre-assembled Arduino modules cost less than
$50
Cross-platform - The Arduino Software (IDE) runs on Windows, Macintosh
OSX, and Linux operating systems. Most microcontroller systems are limited to
Windows.
Simple, clear programming environment - The Arduino Software (IDE) is easy-
to-use for beginners, yet flexible enough for advanced users to take advantage of as
well. For teachers, it's conveniently based on the Processing programming
environment, so students learning to program in that environment will be familiar
with how the Arduino IDE works.
Open source and extensible software - The Arduino software is published as
open source tools, available for extension by experienced programmers. The
language can be expanded through C++ libraries, and people wanting to
understand the technical details can make the leap from Arduino to the AVR C
programming language on which it's based. Similarly, you can add AVR-C code
directly into your Arduino programs if you want to.
 Open source and extensible hardware - The plans of the Arduino boards are
published under a Creative Commons license, so experienced circuit designers
can make their own version of the module, extending it and improving it. Even
relatively inexperienced users can build the breadboard version of the
module in order to understand how it works and save money.

Arduino IDE
Introduction to Arduino IDE where IDE stands for Integrated Development
Environment – An official software introduced by Arduino.cc, that is mainly
used for writing, compiling and uploading the code in the Arduino Device.
Almost all Arduino modules are compatible with this software that is an open
source and is readily available to install and start compiling the code on the go.

 Arduino IDE is an open source software that is mainly used for writing and
compiling the code into the Arduino Module.
 It is an official Arduino software, making code compilation too easy that
even a common person with no prior technical knowledge can get their feet wet
with the learning process.
 It is easily available for operating systems like MAC, Windows, Linux and
runs on the Java Platform that comes with inbuilt functions and commands that
play a vital role for debugging, editing and compiling the code in the
environment.
 A range of Arduino modules available including Arduino Uno, Arduino
Mega, Arduino Leonardo, Arduino Micro and many more.
 Each of them contains a microcontroller on the board that is
actually programmed and accepts the information in the form of code.
 The main code, also known as a sketch, created on the IDE platform will
ultimately generate a Hex File which is then transferred and uploaded in the
controller on the board.
 The IDE environment mainly contains two basic parts: Editor and Compiler
where former is used for writing the required code and later is used for
compiling and uploading the code into the given Arduino Module.
 This environment supports both C and C++ languages.

The IDE environment is mainly distributed into three sections

 1. Menu Bar
 2. Text Editor
 3. Output Pane
As you download and open the IDE software, it will appear like an image below.
 The bar appearing on the top is called Menu Bar that comes with five different
options as follow
 File – You can open a new window for writing the code or open an existing
one. Following table shows the number of further subdivisions the file option is
categorized into.
As you go to the preference section and check the compilation section, the Output
Pane will show the code compilation as you click the upload button.
And at the end of compilation, it will show you the hex file it has generated for the
recent sketch that will send to the Arduino Board for the specific task you aim to
achieve.

 Edit – Used for copying and pasting the code with further modification for
font
 Sketch – For compiling and programming
 Tools – Mainly used for testing projects. The Programmer section in this
panel is used for burning a bootloader to the new microcontroller.
 Help – In case you are feeling skeptical about software, complete help is
available from getting started to troubleshooting.
The Six Buttons appearing under the Menu tab are connected with the running
program as follow.
 The check mark appearing in the circular button is used to verify the code.
Click this once you have written your code.
 The arrow key will upload and transfer the required code to the Arduino
board.
 The dotted paper is used for creating a new file.
 The upward arrow is reserved for opening an existing Arduino project.
 The downward arrow is used to save the current running code.
 The button appearing on the top right corner is a Serial Monitor – A
separate pop-up window that acts as an independent terminal and plays a vital
role for sending and receiving the Serial Data. You can also go to the Tools
panel and select Serial Monitor, or pressing Ctrl+Shift+M all at once will open it
instantly. The Serial Monitor will actually help to debug the written Sketches
where you can get a hold of how your program is operating. Your Arduino
Module should be connected to your computer by USB cable in order to activate
the Serial Monitor.
 You need to select the baud rate of the Arduino Board you are using right
now. For my Arduino Uno Baud Rate is 9600, as you write the following code
and click the Serial Monitor, the output will show as the image below.
The Arduino UNO board layout
What is a Microcontroller?
A microcontroller is a very small computer that has digital electronic devices
(peripherals) built into it that helps it control things. These peripherals allow it
to sense the world around it and drive the actions of external devices. Example
of a use: sense a temperature and depending on the value sensed it could either
turn on a fan if things were too warm or turn on a heater if things were too
cool.

Digital Output : LED

LEDs (Light Emitting Diodes)
have been used as indicator
lights for decades in things like
alarm clocks and entertainment
systems, but recently they have
started taking over many
general lighting tasks since they
are durable and very energy
efficient. LED converts
electrical energy into light
energy. They are polarized
(electricity flows in one
direction). The longer leg is
anode, connects to the power.
The shorter is cathode, connects to the ground.

Arduino - Board Description

Power USB
Arduino board can be powered by using the USB cable from your computer.
All you need to do is connect the USB cable to the USB connection (1).

Power (Barrel Jack)

Arduino boards can be powered directly from the AC mains power supply
by connecting it to the Barrel Jack (2).

Voltage Regulator
The function of the voltage regulator is to control the voltage given to the
Arduino board and stabilize the DC voltages used by the processor and other
elements.

Crystal Oscillator
The crystal oscillator helps Arduino in dealing with time issues. How does
Arduino calculate time? The answer is, by using the crystal oscillator. The
number printed on top of the Arduino crystal is 16.000H9H. It tells us that
the frequency is 16,000,000 Hertz or 16 MHz.

Arduino Reset
You can reset your Arduino board, i.e., start your program from the
beginning. You can reset the UNO board in two ways. First, by using the
reset button (17) on the board. Second, you can connect an external reset
button to the Arduino pin labelled RESET (5).

Pins (3.3, 5, GND, Vin)

 3.3V (6) − Supply 3.3 output volt
 5V (7) − Supply 5 output volt
 Most of the components used with Arduino board works fine with 3.3
volt and 5 volt.
 GND (8)(Ground) − There are several GND pins on the Arduino, any
of which can be used to ground your circuit.
 Vin (9) − This pin also can be used to power the Arduino board from
an external power source, like AC mains power supply.

Analog pins
The Arduino UNO board has six analog input pins A0 through A5. These
pins can read the signal from an analog sensor like the humidity sensor or
temperature sensor and convert it into a digital value that can be read by the
microprocessor.

Main microcontroller
Each Arduino board has its own microcontroller (11). You can assume it as
the brain of your board. The main IC (integrated circuit) on the Arduino is
slightly different from board to board. The microcontrollers are usually of
the ATMEL Company. You must know what IC your board has before
loading up a new program from the Arduino IDE. This information is
available on the top of the IC. For more details about the IC construction and
functions, you can refer to the data sheet.

ICSP pin
Mostly, ICSP (12) is an AVR, a tiny programming header for the Arduino
consisting of MOSI, MISO, SCK, RESET, VCC, and GND. It is often
referred to as an SPI (Serial Peripheral Interface), which could be considered
as an "expansion" of the output. Actually, you are slaving the output device
to the master of the SPI bus.

Power LED indicator

This LED should light up when you plug your Arduino into a power source
to indicate that your board is powered up correctly. If this light does not turn
on, then there is something wrong with the connection.

TX and RX LEDs
On your board, you will find two labels: TX (transmit) and RX (receive).
They appear in two places on the Arduino UNO board. First, at the digital
pins 0 and 1, to indicate the pins responsible for serial communication.
Second, the TX and RX led (13). The TX led flashes with different speed
while sending the serial data. The speed of flashing depends on the baud rate
used by the board. RX flashes during the receiving process.

Digital I/O
The Arduino UNO board has 14 digital I/O pins (15) (of which 6 provide
PWM (Pulse Width Modulation) output. These pins can be configured to
work as input digital pins to read logic values (0 or 1) or as digital output
pins to drive different modules like LEDs, relays, etc. The pins labeled “~”
can be used to generate PWM.

AREF
AREF stands for Analog Reference. It is sometimes, used to set an external
reference voltage (between 0 and 5 Volts) as the upper limit for the analog
input pins.
Sketch
A sketch is the name that Arduino uses for a program. It's the unit of code that
is uploaded to and run on an Arduino board.

The first few lines of the Blink sketch are a comment:

/*
* Blink
*
* The basic Arduino example. Turns on an LED on for one second,
* then off for one second, and so on... We use pin 13 because,
* depending on your Arduino board, it has either a built-in LED
* or a built-in resistor so that you need only an LED.
*
*/
Everything between the /* and */ is ignored by the Arduino when it runs the sketch
(the * at the start of each line is only there to make the comment look pretty, and
isn't required). It's there for people reading the code: to explain what the program
does, how it works, or why it's written the way it is. It's a good practice to
comment your sketches, and to keep the comments up-to-date when you modify
the code. This helps other people to learn from or modify your code.

There's another style for short, single-line comments. These start with // and
continue to the end of the line. For example, in the line:

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

the message "LED connected to digital pin 13" is a comment.

 How an Arduino Program Works?

Arduino Sketch

Arduino sketch is the name that Arduino uses for a program. It’s the unit of code
that is uploaded to, and run on an Arduino board. A basic Arduino sketch consists
of two functions:
 setup()
 loop()
For now, open the Arduino IDE and click on the File tab. Then, click on New (or
press Control + N on your keyboard) to have a look at the two functions.
sketch structure:

• setup : It is called only when the Arduino is powered on or reset. It is used to

initialize variables and pin modes

• loop : The loop functions runs continuously till the device is powered off. The
main logic of the code goes here. Similar to while (1) for micro-controller
programming.
The setup() Function
Statements in the setup() function are executed only once when the sketch is run
(which you must have noticed in the Hello World sketch).
 The loop() Function
Statements in the loop() function will run continuously from top to bottom and
then back to the top.

How to Run the Sketch

Follow the steps below to run the sketch:

1. Connect your evive to your computer using a USB cable.
2. Click the Upload button to load the program to the Arduino.
3. Now open the Arduino IDE Serial Monitor Window to see the sketch run
and print the text message. The text that the program shows should be visible
in the serial monitor window.

Arduino Sketch Program Flow

// Hello World Program

void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
Serial.println("Hello World");
}

void loop() {
// put your main code here, to run repeatedly:

In an Arduino sketch, program statements (individual lines of code) are executed,

i.e. run from top to bottom. This top-to-bottom execution of statements can be
altered only by flow control statements.
There are few things to notice in your sketch:
 1. void setup(): It is the function initialisation/declaration process of the
function named setup(). As the function does not return any value, it is
initialised with the keyword void, meaning empty.
2. Serial.begin(9600);
Serial.println(“Hello World”);
These statements are present in the setup function’s body.
3. { is the opening brace of the functions that tells that all statements starting
from here are inside the fuctions.
4. } is the closing brace of the function.
5. ; is used to terminate the statement.
In the Hello World sketch, statements in the setup() function will run first, from
top to bottom. The statement Serial.begin(9600); is the first statement in
the setup() function, so it is the first to run. This statement sets up the speed of the
serial port to 9600 baud. The baud setting in the serial monitor window must match
this value so that the evive and serial monitor window can communicate at the
same speed.
The second statement to run in the setup() function is Serial.println(“Hello,
world!”);, which sends the text Hello World out for display in the serial monitor
window. In this statement, any text can be put between the opening and closing
quotes (” “) and it will be displayed in the serial monitor window.

Arduino - Program Structure

the Arduino program structure and we will learn more new terminologies used in
the Arduino world. The Arduino software is open-source. The source code for the
Java environment is released under the GPL and the C/C++ microcontroller
libraries are under the LGPL.
Sketch − The first new terminology is the Arduino program called “sketch”.

Structure

Arduino programs can be divided in three main parts: Structure,

Values (variables and constants), and Functions. In this tutorial, we will learn
about the Arduino software program, step by step, and how we can write the
program without any syntax or compilation error.
Let us start with the Structure. Software structure consist of two main functions −

 Setup( ) function
 Loop( ) function

Void setup ( ) {

}
 PURPOSE − The setup() function is called
when a sketch starts. Use it to initialize the
variables, pin modes, start using libraries, etc.
The setup function will only run once, after
each power up or reset of the Arduino board.
 INPUT − -
 OUTPUT − -
 RETURN − -

Void Loop ( ) {

}
 PURPOSE − After creating a setup() function, which initializes and sets
the initial values, the loop() function does precisely what its name suggests,
and loops consecutively, allowing your program to change and respond.
Use it to actively control the Arduino board.
 INPUT − -
 OUTPUT − -
 RETURN − -
 Arduino - Data Types
Data types in C refers to an extensive system used for declaring variables or
functions of different types. The type of a variable determines how much space it
occupies in the storage and how the bit pattern stored is interpreted.
The following table provides all the data types that you will use during Arduino
programming.
void Boolean char Unsigned byte int Unsigned word
char int

long Unsigned short float double array String- String-

long char array object

void

The void keyword is used only in function declarations. It indicates that the
function is expected to return no information to the function from which it was
called.

Example
Void Loop ( ) {
// rest of the code
}

Boolean

A Boolean holds one of two values, true or false. Each Boolean variable occupies
one byte of memory.

Example
boolean val = false ; // declaration of variable with type boolean and initialize it
with false
boolean state = true ; // declaration of variable with type boolean and initialize it
with true
Char

A data type that takes up one byte of memory that stores a character value.
Character literals are written in single quotes like this: 'A' and for multiple
characters, strings use double quotes: "ABC".
However, characters are stored as numbers. You can see the specific encoding in
the ASCII chart. This means that it is possible to do arithmetic operations on
characters, in which the ASCII value of the character is used. For example, 'A' + 1
has the value 66, since the ASCII value of the capital letter A is 65.
Example
Char chr_a = ‘a’ ;//declaration of variable with type char and initialize it with
character a
Char chr_c = 97 ;//declaration of variable with type char and initialize it with
character 97
unsigned char

Unsigned char is an unsigned data type that occupies one byte of memory. The
unsigned char data type encodes numbers from 0 to 255.

Example
Unsigned Char chr_y = 121 ; // declaration of variable with type Unsigned char
and initialize it with character y

byte

A byte stores an 8-bit unsigned number, from 0 to 255.

 Example
byte m = 25 ;//declaration of variable with type byte and initialize it with 25

int

Integers are the primary data-type for number storage.

int stores a 16-bit (2-byte) value. This yields a range of -32,768 to 32,767
(minimum value of -2^15 and a maximum value of (2^15) - 1).
The int size varies from board to board. On the Arduino Due, for example,
an int stores a 32-bit (4-byte) value. This yields a range of -2,147,483,648 to
2,147,483,647 (minimum value of -2^31 and a maximum value of (2^31) - 1).
Example
int counter = 32 ;// declaration of variable with type int and initialize it with 32

Unsigned int

Unsigned ints (unsigned integers) are the same as int in the way that they store a 2
byte value. Instead of storing negative numbers, however, they only store positive
values, yielding a useful range of 0 to 65,535 (2^16) - 1). The Due stores a 4 byte
(32-bit) value, ranging from 0 to 4,294,967,295 (2^32 - 1).

Example
Unsigned int counter = 60 ; // declaration of variable with
type unsigned int and initialize it with 60

Word

On the Uno and other ATMEGA based boards, a word stores a 16-bit unsigned
number. On the Due and Zero, it stores a 32-bit unsigned number.

Example
word w = 1000 ;//declaration of variable with type word and initialize it with 1000

Long

Long variables are extended size variables for number storage, and store 32 bits (4
bytes), from -2,147,483,648 to 2,147,483,647.
 Example
Long velocity = 102346 ;//declaration of variable with type Long and initialize it
with 102346

unsigned long

Unsigned long variables are extended size variables for number storage and store
32 bits (4 bytes). Unlike standard longs, unsigned longs will not store negative
numbers, making their range from 0 to 4,294,967,295 (2^32 - 1).

Example
Unsigned Long velocity = 101006 ;// declaration of variable with
type Unsigned Long and initialize it with 101006

short

A short is a 16-bit data-type. On all Arduinos (ATMega and ARM based), a short
stores a 16-bit (2-byte) value. This yields a range of -32,768 to 32,767 (minimum
value of -2^15 and a maximum value of (2^15) - 1).
Example
short val = 13 ;//declaration of variable with type short and initialize it with 13

float

Data type for floating-point number is a number that has a decimal point.
Floating-point numbers are often used to approximate the analog and continuous
values because they have greater resolution than integers.
Floating-point numbers can be as large as 3.4028235E+38 and as low as -
3.4028235E+38. They are stored as 32 bits (4 bytes) of information.

Example
float num = 1.352;//declaration of variable with type float and initialize it with
1.352
double

On the Uno and other ATMEGA based boards, Double precision floating-point
number occupies four bytes. That is, the double implementation is exactly the
same as the float, with no gain in precision. On the Arduino Due, doubles have 8-
byte (64 bit) precision.

Example
double num = 45.352 ;// declaration of variable with type double and initialize it
with 45.352

Arduino - Variables & Constants

What is Variable Scope?

Variables in C programming language, which Arduino uses, have a property

called scope. A scope is a region of the program and there are three places where
variables can be declared. They are −

 Inside a function or a block, which is called local variables.

 In the definition of function parameters, which is called formal parameters.
 Outside of all functions, which is called global variables.

Local Variables
Variables that are declared inside a function or block are local variables. They can
be used only by the statements that are inside that function or block of code. Local
variables are not known to function outside their own. Following is the example
using local variables −
Void setup () {

Void loop () {
 int x , y ;
int z ; Local variable declaration
x = 0;
y = 0; actual initialization
z = 10;
}

Global Variables
Global variables are defined outside of all the functions, usually at the top of the
program. The global variables will hold their value throughout the life-time of
your program.
A global variable can be accessed by any function. That is, a global variable is
available for use throughout your entire program after its declaration.
The following example uses global and local variables −
Int T , S ;
float c = 0 ; Global variable declaration
Void setup () {
}
Void loop () {
int x , y ;
int z ; Local variable declaration
x = 0;
y = 0; actual initialization
z = 10;
}

Arduino - Operators
An operator is a symbol that tells the compiler to perform specific mathematical
or logical functions. C language is rich in built-in operators and provides the
following types of operators −
 Arithmetic Operators
 Comparison Operators
 Boolean Operators
 Bitwise Operators
 Compound Operators

Arithmetic Operators
Assume variable A holds 10 and variable B holds 20 then −
Show Example

Operator name Operator Description Example

simple

assignment Stores the value to the right of the equal sign in

= A=B
operator the variable to the left of the equal sign.

A + B will
addition + Adds two operands
give 30

A - B will
subtraction - Subtracts second operand from the first
give -10

A * B will
multiplication * Multiply both operands
give 200

B / A will
division / Divide numerator by denominator
give 2

Modulus Operator and remainder of after an B % A will

modulo %
integer division give 0

Comparison Operators

Assume variable A holds 10 and variable B holds 20 then −

Show Example

Operator Operator Description Example

name simple

(A == B) is
equal to == Checks if the value of two operands is
not true
equal or not, if yes then condition
 becomes true.

Checks if the value of two operands is

(A != B) is
not equal to != equal or not, if values are not equal then
true
condition becomes true.

Checks if the value of left operand is less

(A < B) is
less than < than the value of right operand, if yes then
true
condition becomes true.

Checks if the value of left operand is

(A > B) is
greater than > greater than the value of right operand, if
not true
yes then condition becomes true.

Checks if the value of left operand is less

less than or (A <= B) is
<= than or equal to the value of right operand,
equal to true
if yes then condition becomes true.

Checks if the value of left operand is

greater than greater than or equal to the value of right (A >= B) is
>=
or equal to operand, if yes then condition becomes not true
true.