Contents

Introduction
Chapter 1: Introduction to Arduino
Chapter 2: Terminology
Chapter 3: Getting Things Ready
Chapter 4: Running a Simple Project
Chapter 5: Project Creation Process
Chapter 6: Pin Layout for the Uno
Chapter 7: Basic Arduino Command Library
Chapter 8: Programming Expressions
Chapter 9: Programming Structures
Chapter 10: Advanced Example
Conclusion
Introduction
Arduinio: Beginner’s Guide. Have you been thinking about investing in an Arduino
board for yourself or someone else? Have you just bought one, and want to make sure
you get a running start? Then this is the book for you!
Written for beginners, it answers quite a few questions, like …
What makes the Arduino special?
Is it compatible with my computer?
Is there any special software I need to buy?
Is there any special equipment I should be so I can get started as soon as I
get it?
It covers the information you need to jump in feet first:
The terminology you need to survive a basic Arduino book
A short example you can build and run, with step by step instructions and
screen shots
A discussion of the project development process
What you need to know about a typical Arduino pin layout
Programming structures, variables, data types, and expressions – everything
a beginner needs to know to begin writing a program for your Arduino
A final, more advanced example to expand your skills and reinforce what
you learned
Are you ready to join in on the adventure of creating cool projects with Arduino
boards? Then you have picked the right book!
Thanks again for downloading this book, I hope you enjoy it!
Chapter 1: Introduction to Arduino

An Arduino microcontroller board can be thought of as a user-friendly, open-source

input-output system. An input can range from anything from a finger pressing a button
to a change in light intensity, and outputs can range from lighting up a simple LED light
to sending out a Twitter message.
What Makes It Special
There are several features of Arduino that truly make is stand out from the rest of the
microcontrollers on the market. For example, the software is open source, so you
can “ look under the hood ” so to speak, and is free to download, modify, and re-use
(which is always a plus for more advanced developers).
Even the basic plans for the Arduino are open source, so users can build their own
without having to buy one. There are several companies that make the Arduinio
boards, too, and you can buy full kits breadboards, wiring sensors, and more. Even
fully assembled, Arduino is on the lower end of the cost spectrum, and is compatible
with Windows, Mac, and Unix systems.
Most importantly for beginners, perhaps, is the fact that the development environment
for the Arduino is aimed at people with little to no microcontroller experience, but
powerful and flexible enough for experienced users. There is a great deal of quality
information out there to help even the most inexperienced user navigate the Arduino
and put it to use in exciting and creative ways
In short, it had made microcontrollers accessible to everybody, even those with a
minimal computer background, regardless of age.
There are many different flavors or Arduino boards, too. At the time this book was
written, Arduino offered 20 different boards. This particular book focuses on the
Arduino Uno.
What You Need
To work with the Arduino, you need a laptop, desktop, or tablet that you can
download the Arduino development environment onto. It is written in Java, and can
be downloaded on Windows, Mac OS X 10.7 Lion or newer, and Linux 32 or 64 bit.
To connect your board with your computer, you will need a USB data cable. Unlike
USB charging or synching cables, they have a square, blocky-shaped interface instead
of a small interface like the micro-usb.
It is recommended that, unless you are a well-established electronics hobbyists with
tons of cool sensors and the like lying around, you invest in a kit. These vary in price,
and can save you time and money by helping you obtain the electronic components that
are compatible with your board – and they usually come with tutorials and source
code.
For testing and prototyping, your laptop provides the power for the Arduino via the
USB data cable. However, for laptop independent projects you will probably want to
provide an independent, portable power source for your project. A link is provided
under online resources that shows how to use battery power for your Arduino.
Online Resource:
Arduino Products: https://www.arduino.cc/en/Main/Products
Arduino Board Specifications: https://www.arduino.cc/en/Products.Compare
Arduino Uno: https://www.arduino.cc/en/Main/ArduinoBoardUno
Batter Power for Arduino: http://www.instructables.com/id/Powering-Arduino-with-
a-Battery/
Chapter 2: Terminology
Whenever you are learning something new, the first hurdle is usually terminology.
Before jumping into an example, we are going to take just a few minutes to cover some
terms and jargon that you need to know to get the most out of this book. Let ’ s get
started!
Breadboard
A breadboard is a reusable tool for building circuits. It allows you to connect circuits
without having to permanently solder them, and is a stable surface for connecting up
your components.

Compiler
A compiler is piece of software that takes a program your write (or sketch, as Arduino
calls it) and translates it into something a computer, or in this case the Arduino
microcontroller, can understand. It is part of the Arduino development environment
discussed in this book.
Device Driver
A device driver is a piece of software that helps your computer communicate with
devices attached to it, like the Arduino board. Without the correct drivers, you
computer cannot communicate with the Arduino board.
EEPROM
EEPROM stands for Electrically Erasable Programmable Read-Only Memory. This
is a type of computer chip that can be written and re-written with code (instructions).
Notice that it is electrically erasable. This means that an electric current can be used
to erase it so that it can be used again. However, when it is erased, the entire chip
must be erased. This is different from RAM, or Random Access Memory, which can
have just certain bytes erased.
RAM is more like writing on sheet of paper with a pencil, where you can erase and
rewrite just the parts you want. EEPROM is like a writing on a sheet of paper with a
pen, where if you erase you need start with a fresh sheet of paper. The electrical
erasure is the equivalent to providing a clean, empty sheet of paper.
External Interrupt
We all know what it means to be interrupted. The definition in computer lingo isn ’ t
much different. An external interrupt means that something has occurred outside of
the computer system or processor and needs attention.
Flash Memory
Flash memory is another type of memory. It retains data whether power is supplied
to it or not. A good example is the typical flash drive: it still stores you files even
when it is not plugged into your computer. It is good for storing memory that may
change, but needs to remain even when powered down.
Input/Output
Digital Input/Output
Digital pins can have one of two values: low or high, where low corresponds to 0 or
false and high corresponds to 1 or true. The number of available digital pins is
another major difference between the different Arduino boards.
The largest boards have 54 input pins and 15 output pins. These would be the MEGA
2560 and the MEGA ADK (both using the ATmega2650 processor). The next largest
is the DUE (with an ATSAM3X8E processor), with 54 input pins and 12 output pins.
The smallest is the Gemma (using the ATtiny85 processor) with only 3 input pins and
2 output pins.
Analog Input/Output
Analog is the opposite of digital. Analog involves a continuous electrical signal,
while digital focuses on a signal that has a value of either one or zero (binary).
Another way that the Arduino boards differs is based on how many analog input and
analog output pins they have. An analog input pin can receive an analog signal as
input to the processor. An analog output pin can provide an analog signal as output
from the processor.
The Esplora (with an ATmega32U4 processor) does not have any analog I/O pins.
Most boards have input pins but not output pins, like the Fio (with an ATmega328P
processor) which has 8 analog input pins and no output pins. The exceptions are the
Zero (with an ATSAMD21G18 processor) which has 6 analog input pins and one
analog output pin, and the Due (with an ATSAM3X8E processor) which has 12 analog
input pins and 2 analog output pins.
One of the interesting things is that you can use analog pins and digital pins by just
setting the either to a high value (to represent a digital 1, or true) or a low value (to
represent a digital 0, or false).
Processor
The processor is what takes computer instructions, figures out what to do with them,
and thenruns them – or “ executes ” them, as the classic computer lingo goes. The
Arduino boards typically use one of the following processors: ATtiny85,
ATmega168V, ATmega2560, ATmega168, ATmega328P, ATmega32U4, AR9331
Linux, ATSAMD21G18, or the ATSAM3X8E/
A processors speed is a measure of how fast it can process instructions, and is given
in units of MHz (or GHz for laptops, desktops, and tablets). Most of the processors
listed above run between 8 MHz and 16 MHz with two exceptions: the AR9331 Linux
400 MHz, and the ASTSAMD21G18 runs at 48 MHz.
PWM Pins
PWM stands for Pulse-width modulation, which is used to encode data in a pulsing
signal (as opposed to, say, a serial signal). A PWM pin supports transmitting data
using pulse-width modulation.
Serial Communication
When serial communication is occurring, it means that two systems are sending
digital pulses back and forth between each other at an agreed upon rate.
Let’s say you and a friend are talking on a cell phone. You agree to take turns with
each person saying what they want to say for five seconds. When you five seconds are
up, you have to stop – even if you aren’t finished. When their five seconds are up, it’s
your turn to talk again and you will need to pick up where you let off. That is serial
communication in a nutshell.
Sketch
The Arduino word for a program (also known as code) is sketch. It consists of the
instructions that you want the Arduino to run. Before it can be used on the Arduino
board, a sketch must be compiled and uploaded to the board.
SPI
The acronym SPI stands for serial peripheral interface, and is a synchronous data
communication protocol for use over short distances.
SRAM
SRAM is an acronym for Static Random Access Memory. It differs from RAM, also
known as DRAM for Dynamic Random Access Memory, in that it does not need to be
periodically refreshed. As long as an SRAM has power, it retains memory. That
makes it faster than RAM or DRAM. You can think of RAM as a forgetful person who
needs to keep checking something to remember what it is. SRAM doesn ’ t need to
double check because it always remembers.
UART
The acronym UART stands for Universal Asynchronous Receiver/Transmitter. It is a
microchip that is used to convert between serial and parallel data. For example, it
may receive information from several parallel streams of data, but it can convert those
multiple, parallel stream into a single serial stream. On the other hand, it may receive
a single serial stream of data from an outside source (such as a modem) and converts
that into a set of multiple, parallel streams that the system can work with better.
In short, a UART chip empowers your system to communicate not just using data sent
in parallel, but also data sent in a single, serial stream.
Chapter 3: Getting Things Ready

Now that you understand a bit of the lingo, it ’ s time to jump feet first into a project.
However, you need to get things ready first.
The first thing you need, of course, is an Arduino board. This book makes use of the
Uno board. You will also need a USB data cable, as discussed earlier.
You will need to download the software environment for running the Arduino. You
can find it here: https://www.arduino.cc/en/Main/Software. At the time of this book,
the latest build was Arduino 1.6.5.

As you can see, downloads are available for Windows, Max OS X and both 32 and 64
bit Linux.
This example will download the software on a Windows system with admin rights. If
you are installing the software and do not have administrator rights on your system,
you will want to download the ZIP file instead of the Installer. Download the file
(you may be asked for a donation, but that isn ’ t necessary) and save it to your
computer. Depending on your internet connection speed, it may take a while.
Once it downloads, run it. If asked if you want to allow it to make changes to your
computer, say yes (that ’ s the only way you can get it installed). Next, you should see
the licensing agreement.
Click I Agree if you do agree.
Next you will see the Setup and Installation options screen.

Click Next. It will ask you where you want it installed on the next screen, and it ’ s
best to go with the default that it suggests.
Click Install, and it will begin the installation process.

After the main installation is complete, you will be asked to install the drivers.
Click “ Install ” .
Once installation is finished, you will receive a notification screen that will look
something like this:
Chapter 4: Running a Simple Project

In this chapter, we are going to create a simple project. The purpose of this project is
not only to familiarize you with the basics of the Arduino, but also help you to make
sure all your settings are correct. We are going to start out by discussing the
equipment and electronic devices you need. Next, we are going to take a general look
at the steps needed to develop an Arduino project. We then start up the Arduino
environment, type in the sketch, build the circuit, and get ready to test it out.
Requirements
Here is what you will need to build this simple project:
A laptop or desktop computer upon which you can install the Arduino
development environment
Arduino board (this example uses a Uno board)
USB data cable
A simple button
A 10 k Ω resistor
A basic breadboard
Some wires
The Development Process
Here is the process for creating a program to run on your Arduino:
1. Create the sketch in the Arduino software
2. Verify the sketch
3. Correct any errors that are indicated (like typos or misspelled variable
names)
4. Compile the sketch
5. Upload the resulting program to your Arduino
6. Test your program
7. Rewire or rewrite code as needed
 8. Return to Step 2
In the Arduino software, you will notice that 4 and 5 occur at the same time. You will
probably notice that Steps 3 and 7 are the most frustrating and time consuming, but
they are.
Getting Ready
The first step is to plug the square end of a USB data cable into your Arduino, and the
other end into your computer.
Next, start the Arduino program. You firewall may block it, but you need to give it
permission to be allowed through the firewall. Next, you will see the Arduino
development interface.

Creating the Circuit

What we are going to do is write some code to respond to a button being pushed.
Here is a simple four-pin button just like the one used in this example:

Here is the circuit, created on a breadboard and represented using the Fritzing app:
The red wires represent voltage coming in, and you will notice that the red wire is
connected first to the five volt source, then to the five volt line on the breadboard.
From there, it is connected to a pin on the button.
The black wires represent voltage going back to ground. The black wire is first
connected to a GND (ground) pin, then to the ground line on the breadboard. From
there a wire runs from ground to a 10 k Ω resistor. The resistor connects to a pin on
the button.
The green wire represents the flow of information between the button and the board.
If the button is closed, then a signal of HIGH is sent to pin 2. If the button is open, a
signal of LOW is recognized at pin 2.
Writing the Sketch
Here is the sketch code, complete with comments (those are the lines with a double
slash // in front of the computer – the computer will ignore everything after the slash).
// These commands create two constants (indicated by the word const), which means
// that there values will never change while the program is running
// They are both set to data type int, which means that they will have an integer
// value associated with them
const int buttonPin = 2; // the number of the pin on the board that is connected
// to the pushbutton, and will receive input from the
// pushbutton pin
const int ledPin = 13; // the number of the LED pin on the board

// This command creates a variable of data type int (for integer)

// whose value can change; its purpose is to hold a value to indicate
// whether or not the button has been pushed
int buttonStatus = 0;

// This is the setup code, which is only once run

void setup() {
// initialize the LED pin (remember we set that to pin 13) as an output using
// the function pinMode with two parameters: the pin number and whether it is
// to be used an output pin (as in this case), or an input pin
pinMode(ledPin, OUTPUT);
// initialize the pushbutton pin (which we set as pin 2) as an input:
pinMode(buttonPin, INPUT);
}

void loop() {
// read the value of the pushbutton value and store it in the variable buttonStatus
buttonStatus = digitalRead(buttonPin);

// if the button is pressed, it will have a state of HIGH, so turn the LED light on
if (buttonStatus == HIGH) {
// the function digitalWrite is used to write a value of HIGH to the ledPin
// it has two parameters: the pin number to be written to and the value that
// needs to be written to it
digitalWrite(ledPin, HIGH);
}
else {
// if the button is not pressed, then turn it off
digitalWrite(ledPin, LOW);
}
}

Here is the part of the code you actually need to type in, and it must be typed in exactly
as it appears here:
const int buttonPin = 2;

const int ledPin = 13;

int buttonStatus = 0;

void setup() {
pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT);
}

void loop() {
buttonStatus = digitalRead(buttonPin);
if (buttonStatus == HIGH) {
digitalWrite(ledPin, HIGH);
}
else {
digitalWrite(ledPin, LOW);
}
}

Save and Verify

Once your code is typed in, you need to save your file. Give it a file name you can
easily recognize. Next, click the Verify button to check your code for any syntax
errors.
You will see a message at the bottom of the screen saying, “ Compiling
sketch, ” which means it is working to translate your sketch program into a language
the Arduino board can understand.
If there are no errors, you should see something like this:
Upload your Program
Next, its time to upload your program to the Arduinio board.
Troubleshooting
You may get an error like this one:

First, make sure the correct type of board is selected. Go to Tools … Board … and
select the correct one. The one used in this example is an Arduino Uno. Then try
again. If you still get an error, the next step is to check that the correct port is being
used.
Next, go to Tools … Port … Serial Port. If you are running Windows, click Com
Port. Now try uploading it again.
If you are still having trouble, restart the Arduino software. Once you have restarted it,
open your last sketch by going to File … Open Recent. Now try uploading it again.
Once it uploads correctly, you should see a message like this:

You will need to set the COM port each time you open the Arduino environment, or
you will get the same error.
Testing
The green power LED light should still be one, but no other LED lights should be on.
Now try pressing the button and see what happens. The LED light on the board should
light up.
Online Resource:
Troubleshooting Uploads: https://www.arduino.cc/en/Guide/Troubleshooting#upload
Chapter 5: Project Creation Process

In this chapter, we are going to look at the Arduino project creation process for
programming and using an Arduino microcontroller. We are going to study the phases
involved, then revisit the simple example from the previous chapter in terms of these
phases.
Introduction
There are phases to creating a working microcontroller project:
1. Specify
2. Design
3. Prototype
4. Algorithm
5. Sketch
6. Compile and Upload
7. Test and Debug
Now we are going to look at these phases in more detail.
Specify
Before you can create a good microcontroller project, you must decide exactly what it
needs to accomplish. Then, ask things like this: What kind of input does it need? What
kind of output needs to be achieved? What will you do with the input? How will you
generate the output?
Design
You will need to design a circuit, within the limitations of your Arduinio board, to
achieve the input and output. At this stage, you will begin to look what kind of
electrical or electronic parts you will need, such as resistors, sensors, etc. Make a list
of what you need, and research what you don ’ t know. You will also need to select
which pins you want (or must) use.
Prototype
The next step is to build a prototype of your circuit. You can do this directly on the
breadboard, or if you prefer you can use an online prototyping tool.
Algorithm
This is an often neglected aspect of program development. Before you dive into
writing sketch code, take some time to think through what you sketch needs to do.
When you open up the Arduino environment to create a new Sketch, this is what you
see:

The Sketch is divided into two parts: setup and loop. Consider this their first
guidelines on how to develop a working sketch.
The setup portion is where you put code that needs to run only once. This includes
things like setting certain pins to HIGH, specifying whether a pin should be used as
input or output, assigning certain values to variables, etc. This code will run once
each time the Arduino board is powered up. Decide what commands need to run
once, and plan to place them here.
The loop section is the main portion of the code that will keep running until you power
off the Arduino. This is the more challenging part of developing the algorithm.
Sketch
Here is where you begin to type in the actual commands, being careful about spelling
and syntax.
Compile and Upload
In the example, we saw that we could verify and compile the code at the same time.
This is a step that takes place under the hood, so to speak. As long as we have typed
in the code in a way the computer can understand, then there shouldn ’ t be any issues
with compiling.
Next, the code must be uploaded to the Arduinio. It doesn ’ t do you any good until it
is uploaded.
Test and Debug
This is the most time consuming part of programming. When you run you test, why
doesn ’ t it work correctly? I would start first by checking the code again, then
checking the circuit.
Revisiting the Example
Let ’ s revisit the button example.
1. Specify: the goal is to light up an LED when the user pushes a button
1. Input: signal from the button if it is pushed
2. Output: LED light
3. Processing: the button produces a signal if it is pushed, and that
signal can be checked to determine if the button is pushed; if it
is pushed, then the LED light needs to be on
2. Design
1. Equipment: Need a button; Need an LED light, can use the LED
light built into the board at pin 13; Breadboard; Wires
2. Voltage source: 5V source pin
3. Ground: GND pin
4. Design a simple circuit on paper
3. Prototype: build your prototype circuit on a breadboard

4. Algorithm
1. Initialization: set constants to represent which pin serves as
input from the button, which pin will be used for the LED;
create a variable that sets the initial button status to off
2. Setup: before the main section of the Program runs, the LED pin
needs to be configured as output and the button pin needs to be
 configured for input
3. Loop: read the current button status and if it is high, then turn
the LED on, otherwise don ’ t
5. Sketch:

The yellow represents the initial values that need to be set. The green block is
the setup block, and the red block is the loop block that keeps running until you
turn the Arduino off. Note that a carefully written algorithm can easily be
translated into an actual sketch.
6. Compile and Upload: we compiled the code originally, but needed to
make some adjustment before it could be upload
7. Test and Debug: make sure the circuit works as expected
Online Resources:
Fritzing: http://fritzing.org/home/
Autodesk 123d Circuits: https://123d.circuits.io/
Chapter 6: Pin Layout for the Uno
Now that you know the basics of how to develop an Arduino project, it’s time to get
down to some of the nuts and bolts. In this chapter we are going to look in depth at the
pin layout, and discuss some special purpose pins.
Basic Layout
There are 14 pins on the Uno that can be used as either input or output. The figure
below, taking from Fritzing app, shows a representation of the Uno board. The pin
groupings are divided into three groups: Power, Analog In and Digital.
The Power pins include a VIN pin for voltage input, 2 grounds (GND), a 5 V voltage
source. There are 6 analog input pins, numbered A0 – A5. There are 14 digital pins:
0 – 13. The pins with a ~ can also be used for PWM (as discussed in just a moment).
AREF, used to provide a reference voltage when using the analog input pins, and
Reset, which resets the microcontroller.

Special Purpose Pins

There are also pins with certain functions:
Serial, pins 0 and 1, which can be used to for serial communication; 0 is
for receiving and 1 is for transmitting
External Interrupts, pins 2 and 3, which can be setup to trigger an action
based on some external condition the system detects
PWM, pins 3, 5, 6, 9, 10, 11; used for output via 8-bit using pulse-width
modulation
SPI, pins 10, 11, 12, and 13
LED, pin 13 (which you used in the example from the previous chapter)
The pin numbers are they appear on the board as the same pin numbers you use in
creating sketches for your Arduino.
Online Resources:
Arduino Uno: https://www.arduino.cc/en/Main/ArduinoBoardUno
Chapter 7: Basic Arduino Command
Library
There are a set of basic commands needed to interact with the Arduino
board. In this chapter, we look at the most common digital and analog
I/O functions you would use in a sketch for the Arduino.
Digital I/O Functions
There are three functions for digital input and output: one to set the mode
of the pin (is it going to be an input pin or an output pin), one to write to
the pin (is it going to be set to HIGH or LOW), and one to read the
current status of the pin (is it set at HIGH or LOW). The commands and
their basic structure are shown below. The values that are italicized are
called parameters and are used to provide information to the functions so
that they can work properly.
pinMode(pin, mode)
The pin number must be an integer value
There are three possible modes: INPUT, OUTPUT,
INPUT_PULLUP
digitalWrite(pin, value)
The pin number must be an integer value
The values are either HIGH or LOW
digitalRead(pin)
The pin number must be an integer value
Will return a value of HIGH or LOW
Analog I/O
As discussed earlier, the Arduino boards include pins for performing analog input and
output. One command is used to set a reference voltage (the value used as the
maximum range of the input voltage), another is used to read the analog voltage, and
the last is used to write the analog voltage. Here are the commands:
analogReference(type)
You can choose from 5 options
DEFAULT is going to be 5 volts (on 5V Arduino boards) or 3.3
volts (on 3.3V Arduino boards)
INTERNAL is a built-in reference that varies with the type of
processor
INTERNAL1V1 is a built-in 1.1V reference, but is only
available on the Mega
INTERNAL2V56:is a built-in 2.56V reference that is also
available only on the Mega
EXTERNAL: this means that you will use whatever voltage is
applied to the AREF pin for the reference voltage
analogRead(pin)
This reads whatever the analog voltage level is at pin
It returns an integer value representing the voltage reading at the
pin
analogWrite(pin, duty cycle)
This command writes a PWM value to the pin
The duty cycle is a value between 0, which means always off,
and 255, which means always on
This can be used for things like strobing a LED light
Online Resources:
Arduino General Code Library:
http://playground.arduino.cc/Main/GeneralCodeLibrary
Chapter 8: Programming Expressions

In a program (or sketch, as Arduino calls them), you will eventually need to make use
of expressions. Expressions are combinations of variables, constants, mathematical
operators, logical operators, etc. In this chapter, we are going to look at what we can
use to make up an expression.
Variables and Data Types
Variables allow you to associate certain values with a name, sort of like a label.
Before you use a variable in a sketch, you need to declare it. To declare it, you need
to assign it a name and a data type. The data type tells the program what type of data
to expect to find stored in the variable.
Here are the most commonly used data types:
boolean: true, false, 1, or 1
char: characters such as ‘ a ’ or ‘ A ’ , represented by integer numbers from
-128 to 127
int: integer numbers with values between -32768 to 32767
long: integer numbers with values between -2157483648 to 2157483647
float: -3.4028e+38 to 3.4028e+38
double: same as float
Here is how to declare a variable named ledPin as data type int with an initial value
of 5:
int ledPin = 5;
Operators
Operators are used to manipulate variables. There are four main types of operators:
assignment, mathematical, logical, and Boolean.
The assignment operator = (what we call an equal sign) calculates the final value of
whatever is on the right-hand side of the = and associates that value with the variable
name on the left-hand side of the equal sign.
The mathematical operators are pretty straightforward: +, -, * (multiple), / (divide)
and % (modulo).
Both The logical operators are == for equal to, != for not equal to, < for less than, >
for greater than, <= for less than or equal to, and >= for greater than or equal to. The
Boolean operators are && for and, || for or, and ! for not. The operators only work
on boolean data types, meaning true, false, 1, or 0.
There are also the increment and decrement operators: ++ and --. If you use ++ after
a variable name, like x++, then it adds 1 to the current value of x. If you use – after a
variable name, then it subtracts 1 from the current value of x.
Expressions
Here is an example of very simple mathematical expression: a = 2*3-5. The
compiler, which is what translates the instructions you write sees the = assignment
operator, so it looks to the left to determine what operations are there and the order
they need to be processed. In this case, going to from left to right and following the
MDAS (multiply-divide-add-subtract) rule, it calculates a value of 1. It then assigns
that value of 1 to the variable a.
Logical expressions make use of Boolean and logical operators, and are used quite
often in your microcontroller sketches. Let ’ s say that you want a certain thing to take
place if pin1 is HIGH or pin2 is HIGH. To create a conditional expression for that,
you would have something like this: (pin1 == HIGH || pin2 == HIGH). The || is the
logical or, which means if either the first or second condition is true, the entire
conditional expression is considered true. If both the pins need to be HIGH, here is
the conditional expression: (pin1 == HIGH && pin2 == HIGH).

Online Resources:
Arduino General Code Library:
http://playground.arduino.cc/Main/GeneralCodeLibrary
Chapter 9: Programming Structures

There are three basic programming structures: sequential, decision, and repetition.
Sequential structures are the easiest: the instructions are performed in the exact order
they appear it the program. Decision structures, also known as branching structures,
allow the computer to select which set of instructions to run based on a condition.
Repetition structures keep repeating the same block of instructions until some
stopping condition is met.
In this chapter, we are going to look at how these structures work, and the correct way
to use them in Arduino sketches.
Decision Structures
The most basic form a decision structure is the if statement, which you saw in the
example program:
if (buttonStatus == HIGH) {
digitalWrite(ledPin, HIGH);
}
else {
digitalWrite(ledPin, LOW);
}

The if blockextends from the word “ if ” all the way down to the last curly brace }.
The condition used to determine which set of instructions to run is this:
buttonStatus==HIGH. If this condition is true, then we set the ledPin to HIGH, which
made the LED light up. If the condition is not true, then it must be false. If the
condition is not true, then we set led Pin to LOW which turns the LED light off. Pretty
straightforward, right?
As a more simple example, consider this:
if (value < 10 ) {
digitalWrite(ledPin, HIGH);
}
In this example, if value is greater than or equal 10, nothing happens; if it is less than 10, then the ledPin is set to
HIGH.

Repetition Structures
Let ’ s say that as long as a pin 3 has a value of HIGH, we want the LED light to be
off.
while ( digitalRead(3) ==HIGH) {
digitalWrite(ledPin,LOW);
}
This is a while block, and it extends from the word while to the last curly brace }. Everything between the curly
braces is repeated until the value of pin 3 is no longer equal to HIGH.
Another type of repetition structure is the for loop. These are used when you can determine how many times a
certain segment of code needs to run. For example, if you need to blink some LED lights a certain number of times.
Let ’ s say we want a certain block of code to be repeated 5 times.
for (int count = 1; count <= 5; count ++) { … }
We need a variable to keep track of how many times the loop has been run. In this case, we set that up as an
integer variable named count. Count starts out with a value of 1. All of this is handles in this snippet of code: int
count = 1;
Next, we need a condition so we can determine if the loop should keep going. In this example it is this: count <= 5.
As soon as count is greater than 5, the loop will stop. Now, what keeps count from always staying at the initial
value of 1? The command count ++, which adds one to count.
So, here is how the for loop works:
Creates a variable named count and gives it a data type of integer and an initial value of 1
It runs the instructions inside the body of the loop, or inside the curly braces.
It adds one to count using the count ++ command
It checks the new value of count versus the condition count <= 5
As long as count is still <=5, the body of the loop is run again
If it is not still <=5, the program exists out of the loop and continues on with whatever instruction
comes after the last curly brace

Online Resources:
Arduino General Code Library:
http://playground.arduino.cc/Main/GeneralCodeLibrary
Chapter 10: Advanced Example

In this chapter, we are going to work through an advanced example project on the
Arduino Uno using RGB LEDs to create varying shades of color using a single LED.
Requirements
Here is what you will need to build this simple project:
A laptop or desktop computer upon which you can install the Arduino
development environment
Arduino board (this example uses a Uno board)
USB data cable
A 4-leg Common Cathode RGB LED
(3) 220 ohm resistors
A basic breadboard
Some wires (preferably red, blue, green, and black)
Using RGB LEDs
In this example, we will be making use of a 4-leg RGB LED. Remember that LED
stands for light-emitting diode, and RGB stands for Red-Green-Blue. Using just the
colors red, green, and blue, an incredible number of colors can be generated. One leg
is called the common cathode, and the other three legs are associated with red, blue,
and green. The common cathode is connected to ground, or GND on your Arduino
board. Each of the other legs will need a 220 Ω resistor in series with them. The legs
will be tied to the PWM pins we discussed earlier.

The colors are varied by sending different PWM (pulse-width modulated) signals to
the red, green, and blue leads of the LED.
Here is the circuit we are going to use:
The black wires go to GND. Notice this is the GND that is on the same side of the
board as the PWM pins. The RGB LED has four pins, and one of the pins is much
longer than the others. That is the cathode pin. That is the pin that connects to ground.
Next, the red wire goes to pin 6, which we know is one of the PWM pins because it
has a ~ beside the number. Similarly, the green wire goes to pin 5 and the blue wire
goes to pin 3. The wire colors correspond to which color the lead goes to.
Development Process
1. Specify: the goal is to use an RGB LED to create different colors
1. Input: none required
2. Output: PWM signasl used to vary the color of the RGB LED
3. Processing: the type of signal will have be varied by the
Arduino board to produce the colors
2. Design
1. Equipment: common cathode RGB LED, (3)220 Ω resistors
2. Voltage source: PWM pins
3. Ground: GND pin on the digital side of the Arduino board
4. Design a simple circuit on paper
3. Prototype: build your prototype circuit on a breadboard
 4. Algorithm
1. Initialization: set constants to represent which pin is red, which
is blue, and which is green
2. Setup: setup the red, blue and green pins for PWM output
3. Loop: cycle through the colors by adjusting the PWM output
using repetition cycles
5. Sketch:
int redPin = 6;
int bluePin = 3;
int greenPin = 5;
const int maxVal = 255;
const int minVal = 0;

void setup() {
pinMode(redPin, OUTPUT);
pinMode(bluePin, OUTPUT);
pinMode(greenPin, OUTPUT);
}

void loop() {
for (int i = 255; i >0; i=i-5) {
for (int j = 255; j >0; j=j-5){
 for (int k = 255; k>0; k=k-5){
analogWrite(redPin, i);
analogWrite(bluePin, j);
analogWrite(greenPin, k);
delay(100);
}
}
}
}

6. Compile and Upload: don ’ t forget to make sure that Tools … Port is
setup correctly.
7. Test and Debug: make sure the circuit works as expected … the LED
should slowly cycle through various colors.
Discussion about the Sketch
Let ’ s look at that code in the sketch again.
int redPin = 6;
int bluePin = 3;
int greenPin = 5;
const int maxVal = 255;
const int minVal = 0;

This declares and initializes some variables and constants. The word const means that
the variable that follows cannot change value while the programming is running.
maxVal is set to 255 because that is the maximum PWM analog signal strength we can
send to one of the LED pins. For example, if the redPin is set to 255, the LED color
will be red.

void setup() {
pinMode(redPin, OUTPUT);
pinMode(bluePin, OUTPUT);
pinMode(greenPin, OUTPUT);
}
This is the setup section of code, that only runs once each time the board is turned on.
It assigns digital pins connected to our red, blue, and green RGB LED pins to be set
for output.
void loop() {
for (int i = 255; i >0; i=i-5) {
for (int j = 255; j >0; j=j-5){
for (int k = 255; k>0; k=k-5){
analogWrite(redPin, i);
analogWrite(bluePin, j);
analogWrite(greenPin, k);
delay(100);
}
}
}
}

In a nutshell, this section of code cycles through the various colors. It use three
repetition structures – for loops – to cycle through various combinations of red, blue
and green. The delay command keeps the color steady for 100 ms.
Try experimenting with some of the values in the code to see what happens. Just make
sure to save your original copy so you can start over if you feel like you messed up.
Other Projects
There are a ton of resources on the web with projects and ideas for using the Arduino.
Here are two links with high quality projects that should help stir your imagination.
Instructables for Arduino: http://www.instructables.com/tag/type-id/category-
technology/channel-arduino/
Top 40 Arduino Projects on the Web: http://hacknmod.com/hack/top-40-arduino-
projects-of-the-web/
Conclusion

I hope this book was able to help you to start enjoying your Arduino board. The next
step is to start exploring new and more advanced projects as you build up your skills!
Finally, if you enjoyed this book and found it useful, would you be kind enough to
leave a review for this book on Amazon? It’d be greatly appreciated!

Click Any Star to Review

the Book
If you liked this book, check out my other books.