Chapter 1

Getting Started with Arduino

Arduino is an open-source microcontroller that enables programming and
interaction; it is programmed in C/C++ with an Arduino library to allow it to
access the hardware. This allows for more flexible programmability and the ability
to use electronics that can interface with Arduino. Because Arduino is open
source, the plans for the circuits are available online for free to anyone who wants
to use and create their own board based on the schematics, as long as they share
what they create. This allows for considerable customizability in projects; till date,
users have built Arduinos of different sizes, shapes, and power levels to control
their projects. Arduino is composed of two major parts:
1. The Arduino board, which is a piece of hardware you work on when you build
your objects.
2. The Arduino IDE, which is a piece of software you run on your computer. You
use the IDE to create a sketch (a small computer program) that you upload to
the Arduino board.
Arduino is different from other platforms in the market because of the
following features:
1. It is a multiplatform environment; it can run on Windows, Macintosh, and
Linux.
2. It is based on a processing programming IDE, which is an easy-to-use devel-
opment environment used by artists and designers.
3. You program it via a USB cable, not a serial port. This feature is useful,
 because many modern computers do not have serial ports.
4. It is open-source hardware and software—if you wish, you can download the
circuit diagram, buy all the components, and make your own Arduino board,
without paying anything to the makers of Arduino.
5. The hardware is cheap.
6. There is an active community of users, so there are many people who can assist
you.
7. The Arduino project was developed in an educational environment, and is
therefore, great for newcomers to get things working quickly.
Owing to these special features, there are many potential applications:
1. Real-world monitoring
• Automated weather station
• Lightning detection
• Sun tracking for solar panels
• Background radiation monitor
• Automatic wildlife detector
• Home or business security system
2. Small-scale control
• Small robots
• Model rockets
• Model aircrafts
• Quadrotor UAVs
• Simple CNCs for small machine tools
3. Small-scale Automation
• Automated greenhouse
• Automated aquarium
• Laboratory sample shuttle
• Precision thermal chamber
• Automated electronic test system
4. Performance Art
• Dynamic lighting control
• Dynamic sound control
• Kinematic structures
• Audience responsive artwork
1.1 Arduino Variants

Arduino is rapidly becoming one of the most popular microcontrollers used in

robotics. There are many different types of Arduino microcontrollers that differ
not only in design and features, but also in size and processing capabilities.
However, there are only two models that use completely different chips: the
Standard and the Mega. The Standard is the basic Arduino that uses the
Atmega8/168/328 chip, whereas the Mega is a different Arduino board with more
I/O pins and uses the beefier Atmega1280 chip.
The makers of Arduino also developed software that is compatible with all
Arduino microcontrollers. The software, also called “Arduino,” can be used to
program any of the Arduino microcontrollers by selecting them from a drop-down
menu. Being open source, and based on C, Arduino users are not necessarily
restricted to this software, and can use a variety of other software to program their
microcontrollers.
There are many additional manufacturers who use open-source schematics
provided by Arduino to make their own boards (either identical to the original, or
with variations to add to the functionality), e.g., DFRobot.
In this chapter, the Arduino Uno R3 and DFRobot Romeo BLE boards are
introduced.
1. Arduino Uno R3
The Arduino Uno is a microcontroller board based on the ATmega328. It has 14
digital input/output pins (of which 6 can be used as PWM outputs), 6 analog
inputs, a 16 MHz ceramic resonator, a USB connection, a power jack, an ICSP
header, and a reset button. It contains everything needed to support the
microcontroller; simply connect it to a computer with a USB cable or power it
with an AC-to-DC adapter or battery to get started. Central to the Arduino
interface board, shown in Fig. 1.1, is an onboard microcontroller.
Specifications of the Arduino UNO R3 are as follows:
• Microcontroller: ATmega328
• Operating Voltage: 5 V
• Input Voltage (recommended): 7–12 V
• Input Voltage (limits): 6–20 V
• Digital I/O Pins: 14 (of which 6 provide PWM outputs)
• Analog Input Pins: 6
• DC Current per I/O Pin: 40 mA
• DC Current for 3.3 V Pin: 50 mA
• Flash Memory: 32 KB of which 0.5 KB is used by the bootloader
• SRAM: 2 KB (ATmega328)
• EEPROM: 1 KB (ATmega328)
• Clock Speed: 16 MHz (Fig. 1.2)
 Digital
Ground Digital I/O In
Analog Reference

Interrupt 1
Interrupt 0
In-circuit Serial

(SPI)MISO
(SPI)MOSI
(I2C)SCL
(I2C)SDA

(SPI)SCK

(SPI)SS
Programmer for Serial Out
USB interface (TX) Serial In
(RX)

Reset Button

In-circuit Serial
USB to
Programmer for
Computer
Atmega328
MISO VCC
SCK MOSI
/RESET GND

7-12V DC
Input

(I2C)SDA
(I2C)SCL
Reset
3.3V Power Ground
5V Power Voltage
In Analog In

Fig. 1.1 Arduino UNO interface board

The Arduino Uno pinout is printed in the silkscreen in the top section. While
this pinout is a good start, it is not a comprehensive guide. At first, you mainly use
the pins in the female headers at the edge of the board (top and bottom in the
photo), as well as the USB, and maybe the power
Tx and Rx are serial UART pins used for RS-232 and USB communications
I2C is another serial communications method that uses a bidirectional data line
(SDA) and a clock line (SCL)
SPI is another serial communications method that uses one line for the master to
transmit (MOSI—Master Out Slave In), another for the master to receive (MISO),
and a third as a clock (SCK)
A/D, the Analog to Digital input, converts an analog voltage into a digital
representation
PWM (Pulse Width Modulator) is used to create a square wave with a specific
duty cycle (high time vs low time)
ICSP is the In Circuit Serial Programming—another way to program the processor
Vcc is the voltage supplied to the processor (+5VDC regulated from a higher input
voltage)
3.3VDC is a regulated voltage (from the higher input voltage) for peripherals
requiring that voltage—50 mA maximum
Fig. 1.2 Arduino Uno R3 pinout diagram

IOREF provides a voltage reference so shields can select the proper power source
AREF is a reference INPUT voltage used by the A/Ds
GND is the ground reference
RESET resets the processor (and some peripherals)
2. DFRobot RoMeo BLE
The DFRobot Romeo BLE All-in-one Microcontroller (ATMega 328) is an
all-in-one Arduino-compatible microcontroller specifically designed for robotic
applications. It benefits from the Arduino open-source platform; it is supported by
thousands of open-source codes, and can easily be expanded with your Arduino-
compatible shields.
This robot controller uses an Atmel ATmega328p as the main microcontroller.
It comes preprogrammed with an Arduino bootloader for compatibility with the
user-friendly Arduino Uno platform.
A secondary Texas Instruments CC2540 microcontroller handles the BLE
Bluetooth Low Energy communication services. It comes preprogrammed with a
firmware that supports transparent serial over Bluetooth and an AT command
interpreter. Both microcontrollers are full programmable.
The Romeo robot controller contains a built in L298 dual channel motor driver
chip. This motor driver can be used to drive two 5–23 V DC motors at up to 2
amps. Screw terminals are provided for connecting two motors and an external
motor power supply.
 The Romeo BLE microcontroller board also has a large number of pin headers
to simplify connections to your robot project. A full set of 3-pin analog and digital
GPIO headers provide access to signal, voltage, and ground lines at each connec-
tion to simplify wiring arrangements. The digital GPIO headers can also be used
to drive servos and a screw terminal can provide an external servo power
supply. A full set of Arduino Uno compatible headers allow you to choose from a
large number of Arduino-compatible shields for expansion. A triplet of I2C
connectors is also provided.
Additional features include five optional user push buttons, a reset button, and a
number of LED status indicators to assist with diagnostics. The optional user
buttons are conveniently wired to a single analog input. They can be enabled or
disabled via a slider switch (Fig. 1.3).

Fig. 1.3 Romeo BLE interface board

 Specifications of the RoMeo BLE are as follows:
• Microcontroller: ATmega328P
• Bootloader: Arduino UNO
• Onboard BLE chip: TI CC2540
• 14 Digital I/O ports
• 6 PWM Outputs (Pin11, Pin10, Pin9, Pin6, Pin5, Pin3)
• 8 10-bit analog input ports
• 3 I2Cs
• Two way H-bridged motor driver with 2A maximum current
• 5 Buttons
• Power Supply Port: USB or DC2.1
• External Power Supply Range: 5–23 V
• DC output: 5 V/3.3 V
• Auto sensing/switching external power input
• Size: 94 mm × 80 mm
Chapter 2
The Basic Functions

2.1 Overview

The code you learn to write for your Arduino is very similar to the code you write
in any other computer language. This implies that all the basic concepts remain the
same and it is simply a matter of learning a new dialect. In the case of Arduino,
the language is based on the C/C++ and can even be extended through C++
libraries. The IDE enables you to write a computer program, which is a set of step-
by-step instructions that you then upload to the Arduino. Your Arduino will then
carry out those instructions and interact with whatever you have connected to it.
The Arduino includes many basic embedded functions, such as the functions for
reading and writing to digital and analog input and output pins, interrupt functions,
mathe- matical functions, and serial communication functions. Arduino functions
are a convenient way to write code such as those for device drivers or commonly
used utility functions. Furthermore, Arduino also consists of many built-in-
examples. You just need to click on the toolbar menu:! File Examples to access
them. These simple programs demonstrate all basic the Arduino commands. They
span from a Sketch Bare Minimum, Digital, and Analog IO, to the use of Sensors
and Displays.
For more information on the Arduino language, see the Language Reference
section of the Arduino web site, http://arduino.cc/en/Reference/HomePage. All
Arduino instructions are online.

2.2 Structure

The basic function of the Arduino programming language is fairly simple and runs
in at least two parts. These two required parts, or functions, enclose blocks of
statements.
 setup(): A function present in every Arduino sketch. Run once before the
loop() function. The setup() function should follow the declaration of any
variables at the very beginning of the program. It is the first function to run in the
program, is run only once, and is used to set pinMode or initialize serial
communication.
loop(): A function present in every single Arduino sketch. This code happens
over and over again—reading inputs, triggering outputs, etc. The loop() is where
(almost) everything happens and where the bulk of the work is performed.

2.3 Digital I/O Functions

Digital I/O will allow us to read the state of an input pin as well as produce a
logical high or low at an output pin. If every potential external connection between
a microcontroller and the outside world had a dedicated wire, the pin count for
controller packages would be high. The ATmega 328P in the Romeo board has
four 8-bit ports plus connections for power, ground and the like, yet it only has 28
physical pins. In general, each bit of a port can be programmed independently;
some for input, some for output, or all of them for the same purpose.
1. pinMode(pin, mode)
Before we use a port, we need to inform the controller about how it should
operate. In the Arduino system, this is usually done via a call to the library
function pinMode(). Here is a description of the function from online
references:
 It should be noted that the pin could be a number or variable with a value
ranging from 0 to 13 or A0 to A5 (when using the Analog Input pins for digital
I/O) corresponding to the pin number printed on the interface board. Furthermore,
Digital pins default as input, so you really only need to set them to OUTPUT in
pinMode().
2. digitalWrite(pin, value)
Once a pin is established as an OUTPUT, it is then possible to turn that pin on or
off using the digitalWrite() function. Its syntax is as follows:
3. digitalRead(pin)
With a digital pin configured as an INPUT, we can read the state of that pin using
the digitalRead() function. Its syntax is as follows:

The pin can be specified as either a variable or constant (0–13) and the result is
either HIGH or LOW.

2.4 Analog I/O Functions

1. analogReference(type)
The Arduino interface board, however, has a convenient pin called AREF located near
digital pin 13 along with a function called analogReference() to provide the Arduino ’s
ADC a reference voltage other than +5 V. This function will effectively increase
the resolution available to analog inputs that operate at some other range of lower
voltages below +5 V. The syntax for this function is as follows.

DEFAULT: the default analog reference of 5 volts (on 5 V Arduino boards) or

3.3 volts (on 3.3 V Arduino boards)
INTERNAL: a built-in reference, equal to 1.1 volts on the ATmega168 or
ATmega328 and 2.56 volts on the ATmega8 (not available on the
Arduino Mega)
INTERNAL1V1: a built-in 1.1 V reference (Arduino Mega only)
INTERNAL2V56: a built-in 2.56 V reference (Arduino Mega only)
EXTERNAL: the voltage applied to the AREF pin (0–5 V only) is used as the
reference.
The function is only called once in a sketch, but must be declared before
analogRead() is used for the first time, making it a suitable candidate for placing in
the setup() function. The type specified relates to the kind of reference voltage that
we want to use.
2. analogRead(pin)
Reads the value from a specified analog pin with a 10-bit resolution. This function
works with the above analogy only for pins (0–5). The analogRead() command
will return a number including or between 0 and 1023.

It takes about 100 ls (0.0001 s) to read an analog input, so the maximum

reading rate is about 10,000 times a second. Furthermore, analogy pins unlike
digital ones, do not need to be first declared as INPUT nor OUTPUT.
3. analogWrite(pin,value)
The Arduino also has the capability to output a Digital signal that acts as an
Analog signal, this signal is called pulse width modulation (PWM). Digital Pins #
3, # 5, # 6, # 9, # 10, and # 11 have PWM capabilities. To output a PWM signal
use the command: analogWrite().

2.5 Advanced I/O Functions

1. shiftOut(dataPin,clockPin,bitOrder,value)
Shifts out a byte of data one bit at a time. Starts from either the most (i.e., the
leftmost) or least (rightmost) significant bit. Each bit is written in turn to a data
pin, after which a clock pin is pulsed (taken high, then low) to indicate that the bit
is available. The syntax is as follows.
 This is known as synchronous serial protocol and is a common way that
microcontrollers communicate with sensors, and with other microcontrollers. The
two devices always stay synchronized, and communicate at close to maximum
speeds, since they both share the same clock line. Often referred to as SPI (syn-
chronous protocol interface) in hardware documentation.
2. pulseIn(pin,value,timeout)
Reads a pulse (either HIGH or LOW) on a pin. For example, if the value is HIGH,
pulseIn() waits for the pin to go HIGH, starts timing, then waits for the pin to go
LOW and stops timing. Returns the length of the pulse in microseconds. Gives up
and returns 0 if no pulse starts within a specified time out. The timing of this
function has been determined empirically and will probably show errors for longer
pulses. Works on pulses from 10 ls to 3 min in length. The syntax is as follows.

Fig. 2.3 Circuit layout for the shift register

Please go to Chap. 4, and refer the example for pulseIn().

2.6 Timer Functions

1. delay(ms)
Pauses the program for the amount of time (in milliseconds) specified as the
parameter. The syntax for the function is as follows.
 Time is specified in milliseconds, where a delay of 1000 ms equals 1 s, 2000
ms equals 2 s, and so on. This value can be expressed as a constant or variable in
the unsigned long data type.
The use of delay() in a sketch has significant drawbacks. No other reading of
sensors, mathematical calculations, or pin manipulations can function during the
delay function, so in effect, it brings most other activities to a halt.
2. delayMicroseconds(us)
Rather than a long delay, the delayMicroseconds() function is used to delay for a
much shorter time. The syntax is as follows:

Unlike delay(), time here is specified in microseconds, or millionths of a

second, where a time period of 1000 ls would equal 1 ms or 0.001 of a second,
10,000 would equal 10 ms or 0.01 of a second, and so on.
3. millis()
Inside the microcontroller on the Arduino board there are three onboard hardware
timers that work in the background to handle repetitive tasks like incrementing
counters or keeping track of program operations. Each of these timers is already
being used in some capacity, usually for handling hardware PWM and system
timing. The millis() function makes use of one of these hardware timers to
maintain a running counter of how many milliseconds the microcontroller has
been running since the last time it was turned on or reset. Because this function
uses a hardware timer, it performs its counting in the background with no impact
on the flow or resources of our source code.

By calling the function, it returns a value in milliseconds that can be used like
any other variable as part of a conditional test, to perform arithmetic operations, or
to be assigned to other variables. Because this function returns a value in an
unsigned long data type, it will overflow, or reset to 0, in about 50 days. It can
also result in undesired problems if an expression is performed on it using other
data types like integers.
4. micros()
Where the millis() function returns the current operating time in milliseconds, the
micros() function does the same, but in microseconds. This could be used in
exactly the same manner as millis(), just on a much smaller scale, effectively
returning the value 1000 for every 1 that millis() would return.

Unlike millis(), micros() will overflow, or reset back to 0, every 70 min.

2.7 Communication Functions

1. Serial.begin(speed)
Opens the serial port and sets the baud rate for serial data transmission. The
typical baud rate for communicating with the computer is 9600, although other
speeds are also supported, i.e., 300, 600, 1200, 2400, 4800, 9600, 14,400,
19,200, 28,800,
38,400, 57,600, or 115,200.

It should be noted that the digital pins 0 (RX) and 1 (TX) cannot be used at the
same time when using serial communication.
2. Serial.available()
Receives the number of bytes (characters) available for reading from the serial
port. This is data that has already arrived and been stored in the serial receive
buffer.

Remember, the hardware serial port on the Arduino microcontroller has a

buffer that can store up to 128 bytes of information so that it is not lost. If no data
is waiting for us, it will return 0. On the other hand, if any data is available, the
function will return a value other than 0, which will signify true. We can proceed
to read from the buffer.

3. Serial.printIn(val,format)
Prints data to the serial port as human-readable ASCII text followed by a carriage
return character (ASCII 13, or ‘\r’) and a newline character (ASCII 10, or ‘\n’).

The println() function is a little easier to use and helps to clean up the output
that we receive from the Serial Monitor. You will often see both the print() and
println() functions used in conjunction to format the output, making the text
easier to read.
2.8 Interrupt Functions

1. attachInterrupt(digitalPinToInterrupt(pin),ISR,mode)
The attachInterrupt() function enables hardware interrupts and links a hardware pin
to an ISR to be called when the interrupt is triggered. This function also specifies
the type of state change that will trigger the interrupt. Its syntax is as follows:
5V 5V

0V 0V

LOW CHANGE

5V 5V

0V 0V

RISING FALLING

Fig. 2.5 State changes

Normally, you should use digitalPinToInterrupt(pin), rather than place an

interrupt number directly into your sketch. The specific pins with interrupts, and
their mapping to interrupt numbers vary for each type of board. On the DFrobot
Romeo board, there are two possible hardware interrupts, 0 (for digital pin 2) and
1 (for digital pin 3).
Four possible modes are shown in Fig. 2.3, which include LOW, CHANGE,
RISING, and FALLING (Fig. 2.5).
2. detachInterrupt(interrupt)
In some cases, we might need to change the mode of an enabled interrupt. For
example, we may change the mode from RISING to FALLING. For this, we need
to first stop the interrupt by using the detachInterrupt() function. Its syntax is as
follows:
 With only one parameter to determine which interrupt we are disabling, this
parameter is specified as either 0 or 1. Once the interrupt has been disabled, we
can then reconfigure it using a different mode in the attachInterrupt() function.
3. interrupts()
All interrupts in Arduino can be enabled by the function interrupts(). The syntax is
as follows:

Interrupts allow certain important tasks to run in the background and are
enabled by default. Some functions will not work while interrupts are disabled,
and incoming communication may be ignored. Interrupts can slightly disrupt the
timing of a code, however, and may be disabled for particularly critical sections
of code.
4. noInterrupts()
To deactivate all interrupts, we can use the function noInterrupts(). The syntax is
as follows.
 2.9 Math Functions

The Arduino language supports many math functions which make it possible to
perform sophisticated data processing in a data logger sketch that would otherwise
have to be performed offline in some other software application.
1. min(x,y)
Calculates the minimum of two numbers

2. max(x,y)
Calculates the maximum of two numbers3.

3.abs(x)
Computes the absolute value of a number

Because of the way the abs() function is implemented, avoid using other func-
tions inside the brackets, it may lead to incorrect results.
3. Trigonometric functions
The trigonometric functions include sin(rad), cos(rad), and tan(rad). All trigono-
metric functions accept as input and return as output angles in radians, not
degrees:radians ¼degrees p=180 and vice versa to convert radians back to
degrees.
4. pow(base,exponent)
Calculates the value of a number raised to a power. pow() can be used to raise a
number to a fractional power. This is useful for generating exponential mapping of
values or curves.

5. sqrt(x)
Calculates the square root of a number.

6. constrain(x,a,b)
Constrains a number to be within a range.
7. map(value,fromLow,fromHigh,toLow,toHigh)
Remaps a number from one range to another. That is, a value of fromLow would be
mapped to toLow, a value of fromHigh to toHigh, values in-between to values in-
between, etc.

8. random(min,max)
The random() function returns a semi-random number up to the parameters spec-
ified. If no parameters are specified, it will return a value in the signed long data
type, with a range of −2,147,483,648–2,147,483,647. Its syntax is as follows:
3.1 ltrasonic Sensors

3.1.1 Introduction

When creating an autonomous target tracking robot, one of the most crucial
aspects is obstacle detection and avoidance. Often, a target may move in a
scenario where there is an object between the target and robot. A sensor must be
able to detect the object, with adequate range to allow the robot to respond and
move accordingly. Ideally, the sensor must be small, low in cost, and easy to
manufacture and must be usable on a large scale. A readily available sensor that
fits all of these requirements is the ultrasonic sensor.
The ultrasonic sensor uses sonar to determine the distance from an object,
similar to bats and dolphins. The sensor is a non-contact distance measurement
equipment that uses a timing variable t, measured from the transmission of some
kind of a pilot signal till a reflected signal is received from the object (Fig. 3.19).
The distance L to the object can be calculated as follows:

vt cos h
L¼ 2 ð3:3Þ

where, v is the speed of ultrasonic waves in the media (i.e., 340 m/s), h is the
reflection angle. If the transmitter and the receiver are close to each other, then
cos h ≈ 1.
Fig. 3.19 The principle of
ultrasonic sensor Object
Transmitter

θ
Receiver
L

For example, if the object is L = 10 cm away from the sensor, and the speed of
sound is 340 m/s or 0.034 cm/µs, the sound wave will need to travel about 294 µs.
However, what you will get from the receiver will be double that number because
the sound wave needs to travel forward and bounce backward. Therefore, in order
to obtain the distance in cm we need to multiply the received travel time value
from the receiver by 0.034 cm/µs and divide it by 2.

3.1.2 HC-SR04

Ultrasonic Sensor HC-SR04 is used here to measure distances in the range of 2 m–

400 cm with an accuracy of 3 mm. The sensor module consists of an ultrasonic
transmitter, receiver, and control circuit. The working principle of an ultrasonic
sensor is as follows:
1. A high level signal is sent for 10 µs using the Trigger.
2. The module sends eight 40 kHz signals automatically, and then detects
whether the pulse is received or not.
3. If the signal is received, then it forms a high level. The time of the high
duration is the time gap between sending and receiving the signal.
4. The distance is calculated using Eq. (3.3).
The timing diagram is shown as Fig. 3.20.

3.1.3 Demonstration

1. Components
• DFRobot UNO R3 board and USB cable × 1.
• HC-SR04 (ultrasonic distance sensor) × 1.
• Jumper wires × n.
 10us TTL
Trigger Input
To module

8 Cycle Sonic Burst

Sonic Burst
From Module

Output proportional
Echo Pulse to range
Output To User
Timing Circuit

Fig. 3.20 Timing diagram

2. Hardware Setting
The ultrasonic sensor HC-SR04 has four pins: VCC, TRIG, ECHO, and GND.
The VCC should be connected to 5 V and the GND to a common ground with
your Arduino. TRIG is used for emitting the transmitted signal. The output pin of
the Ultrasonic sensor should be plugged into a defined pin on the DFRobot UNO
R3 board. The ECHO pin is what is used for detecting the response from the
ultrasonic wave; this two should be plugged into a separate defined pin on the
DFRobot UNO R3 board (Fig. 3.21).

Fig. 3.21 A diagram of the layout of the HC-SR04 and UNO R3

 References

A. Hayes, Arduino: A Quick-Start Beginner’s Guide (CreateSpace Independent Publishing

Platform, 2017)
M. Banzi, M. Shiloh, Getting Started with Arduino: The Open Source Electronics
Prototyping Platform (Maker Media, Inc., 2014)
J. Blum, Exploring Arduino: Tools and Techniques for Engineering Wizardry (Wiley, London,
2013)
B. Francis, Arduino: The Complete Beginner’s Guide (CreateSpace Independent Publishing
Platform, 2016)
K. Chelli, S. Chavhan, Development of wireless sensor node to monitor poultry farm, in
Mobile Communication and Power Engineering. (Springer, Berlin, 2013), pp. 27–32
A.K. Dennis, Raspberry Pi Home Automation with Arduino (Packt Publishing Ltd, 2013)
R. Faludi, Building Wireless Sensor Networks: With ZigBee, XBee, Arduino, and Processing
(O'Reilly Media, Inc., 2010)
S. Ferdoush, X. Li, Wireless sensor network system design using Raspberry Pi and Arduino for
environmental monitoring applications. Procedia Computer Science 34, 103–110 (2014)
M. Geddes, Arduino Project Handbook: 25 Practical Projects to Get You Started (No Starch
Press, 2016)
H. Timmis, Practical Arduino Engineering (Apress, New York, 2011)
H. Harun, A. Mohd Zin, A study using internet of things concept towards engineering education.
Int. J. Adv. Comput. Sci. Technol. 4(6), 133–136 (2015)
J. Purdum, Beginning C for Arduino (2nd edn) (Apress, New York, 2015)
J-D. Warren, J. Adams, H. Molle, Arduino Robotics (Apress, New York, 2011)
J. Bayle, C Programming for Arduino (Packt Publishing Ltd., 2013)
T. Karvinen, K. Karvinen, Make: Arduino Bots and Gadgets: Six Embedded Projects with
Open Source Hardware and Software (O'Reilly Media, Inc., 2011)
P. Kumar, P. Kumar, Arduino based wireless intrusion detection using IR sensor and GSM. Int.
J. Comput. Sci. Mobile Comput. 2(5), 417–424 (2013)
A. Kurniawan, Getting Started with Matlab Simulink and Arduino (PE Press, 2013)
G. Lockridge, Development of a low-cost Arduino-based sonde for coastal applications. Sensors
16(4), 1969–2017 (2016)
M. Margolis, Make an Arduino-Controlled Robot (O'Reilly Media, Inc., 2012)
M. McRoberts, B. Levy, C. Wootton, Beginning Arduino (Apress, New York, 2010)
M. Riley, Programming Your Home: Automate with Arduino, Android, and Your Computer
(Pragmatic Bookshelf, 2012)
Forums

Arduino, Official Arduino forum website (http://www.arduino.org/forums)

Adafruit Industries, Microcontrollers, Adafruit Products, Arduino, and laser cutting
(http://forums. adafruit.com)
AVR Freaks, Programming AVR microcontrollers, using GCC, AVR tutorials (www.avrfreaks.
net/phorum)
BILDR, Tutorial discussion, hardware and software help (http://forum.bildr.org)
DIY Drones, Autonomous unmanned aerial vehicles powered by Arduino (http://diydrones.com/
forum)
MakerBot Industries, Arduino and 3D printing (http://wiki.makerbot.com/forum:start)
Processing, General Processing discussion, project exhibitions, and library development (http://
forum.processing.org)
PureData, All things PD—patches, libraries, and hardware (http://puredata.hurleur.com)
RepRap, More 3D printing and other Arduino Arduino-related stuff (http://forums.reprap.org)
SparkFun Electronics, Electronics, SparkFun products, Arduino, PCB design, and project ideas
(http://forum.sparkfun.com)

Tutorials

Adafruit Industries, Beginning electronics, sensors, and other Arduino tutorials (www.adafruit.
com/tutorials)
Arduino, Official Arduino tutorial website (http://arduino.cc/en/Tutorial/HomePage)
Tutorialspoint, Arduino Tutorial
(https://www.tutorialspoint.com/arduino/index.htm)
Jeremy Blum, Video tutorials from Jeremy Blum (http://jeremyblum.com/category/arduino-
tutorials)
SparkFun Electronics, Embedded electronics, surface mount soldering, projects, and other
tutorials (www.sparkfun.com/tutorials)
Spooky Projects, Class notes and tutorials from Tod E. Kurt (http://todbot.com/blog/
spookyarduino)
Tronixstuff, An ever expanding series of Arduino tutorials from John Boxall (http://tronixstuff.
wordpress.com/tutorials)
Wiring, Tutorials for the Wiring platform, similar to and mostly compatible with Arduino (http://
wiring.org.co/learning/basics)