Arduino

Programming
The Ultimate Guide for Absolute Beginners
with Steps to Learn Arduino Programming
and The Fundamental Electronic Concepts

Daniel Géron
Table of Contents
Introduction
Chapter 1: The Basics of Arduino
The History of Arduino
What is Arduino?
Who Works with Arduino?
The Advantages of Working with Arduino
Chapter 2: The Key Terms to Get Started
The Anatomy of Our Board
Other Terms with Arduino
Chapter 3: How to Set Up Arduino
Picking Out Our Board
Getting Started on the IDE Arduino
Coding a Program On Arduino
Connecting to Our Arduino Board
Uploading the Arduino Board
How to Run Arduino with Your Program
Chapter 4: The Starting Point for Coding in Arduino
The Structure
The Control Structures
The Syntax
The Data Types
Chapter 5: Turning Your Arduino Into a Machine
Create the Circuit
The Useful Constants
Chapter 6: What Do I Need to Know About the C Language.
The Memory Maps
Chapter 7: Looking at Logic Statements
Chapter 8: The Operators
The Arithmetic Operators
The Boolean Operators
Chapter 9: Getting Your Machine to Make Decisions
The If Statements
Chapter 10: The Fun Stuff – Taking a Look at the Sensors, Outputs, and Inputs
Why are Analog Signals Important
How Can Our Sensors Give Us the Analog Signals?
Looking at an Example with a Control Light
Chapter 11: Computer Interfacing with Arduino
The FTDI Chips
Example of Temperature Sensors with Serial Interface
Chapter 12: The API Functions
The Digital Input and Output
Time
Math
The Characters
The Random Numbers
The Bitwise Functions
Chapter 13: Using the Stream Class
The Serial
Chapter 14: Working with User-Defined Functions
 © Copyright 2019 – Daniel Géron - All rights reserved.
The content contained within this book may not be reproduced, duplicated or
transmitted without direct written permission from the author or the publisher.
Under no circumstances will any blame or legal responsibility be held against
the publisher, or author, for any damages, reparation, or monetary loss due to the
information contained within this book. Either directly or indirectly.
Legal Notice:
This book is copyright protected. This book is only for personal use. You cannot
amend, distribute, sell, use, quote or paraphrase any part, or the content within
this book, without the consent of the author or publisher.
Disclaimer Notice:
Please note the information contained within this document is for educational
and entertainment purposes only. All effort has been executed to present
accurate, up to date, and reliable, complete information. No warranties of any
kind are declared or implied. Readers acknowledge that the author is not
engaging in the rendering of legal, financial, medical or professional advice. The
content within this book has been derived from various sources. Please consult a
licensed professional before attempting any techniques outlined in this book.
By reading this document, the reader agrees that under no circumstances is the
author responsible for any losses, direct or indirect, which are incurred as a
result of the use of information contained within this document, including, but
not limited to, — errors, omissions, or inaccuracies.

Introduction
Congratulations on purchasing Arduino Programming and thank you for doing
so.

The following chapters will discuss everything that you need to know in order to
get started with the Arduino coding language. There are many people who are
interested in learning about programming and getting started, but they worry that
the software and hardware, and the other requirements that are needed to even
get started. This is where we will see Arduino and all of its technology come into
play. It was designed to help students learn how to code, and for the non-
engineer who has never been able to do any work with programming in the past.

This doesn’t mean that you are limited to what you are able to do when it comes
to working on some of the projects that you want to do. It simply means that the
board and technology were designed so that it is easier for the beginner to work
with, and that it is able to help you to really get some of the results that you are
looking for when you start out with the coding.

As you will see when we go through this guidebook, there are a lot of different
parts that have to come together to help us to start doing some of the coding that
we want. But when you compare Arduino to some of the other coding languages
that you have maybe looked at in the past, you will find that the language is
simple and easy to read and that you will be able to make it work for your needs
in no time at all.
in no time at all.

And that is what this guidebook is going to be all about. We are going to spend
some time looking at what the Arduino technology is all about, why it can be so
beneficial to many different programmers, why we need to learn about it and
more. Once we are done with some of the introduction, we are then going to
move into some of the meanings that come with the pins we are using, a look at
how to connect the system to the computer that we want to use and more.

Then it is time for some of the fun stuff that comes with this kind of coding, and
all of the codes that you are able to work with. We will look at the API, the
different functions, how to work with the stream class, and more. When this is
done, you will be able to write out a lot of different codes with this language,
and you will soon see why it is the choice of so many programmers to work with
this option, rather than some of the others out there.

We will even take some time to explore a few of the codes that we are able to
write and do a few examples. Sometimes the best way to learn, after getting the
basics down and learning some of the functions that come with the language, is
to actually do some examples and see how it works. This guidebook will have
some examples to go with the various codes that we are trying to write and to
ensure that we are really going to be able to use this technology to write some of
the codes that we want, even as a beginner in the world of coding and of
programming.

Often there is a high learning curve when it is time to work with some new
programming or a new language, especially if you have never done any of the
coding in the first place. This is often scary enough that people will decide not to
work with it at all, and that it is not worth their time to even get started because
it will be too confusing to get started. And this is exactly where the Arduino
board is going to come into use. We will be able to explore some of the basics
that come with this board and learn how to code with it, whether you have done
some coding in the past or not. And this guidebook will be able to show you
exactly how to get this done.

There are a lot of different things that you are able to do with the Arduino board
to get your coding goals done and taken care of in no time. This is what can
really make it the results that you would like when you start out with this coding
language in the first place. When you are ready to learn more about coding with
the Arduino language and all of the cool things that you are able to do when it
comes to coding on the Arduino system, make sure to check out this guidebook
to help you get started.

There are plenty of books on this subject on the market, thanks again for
choosing this one! Every effort was made to ensure it is full of as much useful
information as possible, please enjoy it!
Chapter 1: The Basics of Arduino

With the age of technology that we are in right now, there is an increase in the
amount of technological literacy of the average person. More and more people
out there are becoming versed in some of the hardware and the software that is
out there, and there is even more of interest over time for many to try to work as
an engineer either as a hobby or for a professional.

During this time, many have found themselves attracted to the Arduino system.
Maybe you have seen some of the projects that are done with this system and
built on some of these technologies as well, or maybe you have had a chance to
hear about the ease and the flexibility that comes with the gadgets that work with
Arduino. No matter what the case is if you are interested in learning more about
this process, and how this technology can work in your life, then this is the
guidebook for you to check out.

With this in mind, we need to get more in-depth about what we are able to do
with the Arduino system and technology, and how this is able to provide us with
a number of benefits. We are going to start out with a look at some of the
histories that come with Arduino.
The History of Arduino
The History of Arduino
The technology that is behind Arduino started as just a simple idea in 2003.
Hernando Barragan wanted to start out with a way to simplify the BASIC stamp
microcontroller while also reducing some of the costs that come with it so that
students who were not planning on being engineers would be able to purchase
this kind of technology.

To start with, the microcontroller is going to be a small board on the computer

that we are able to program to help us perform some specific functions along the
way. In 2003, these controllers were going to the case at least $100, and
sometimes more depending on the features that we are able to see with them.
And as we are going to see as we go through this guidebook, Arduino is going to
help reduce the costs of these controllers while still maintaining some of the
ability that is needed in order to perform various functions and more.

This technology was developed and changed throughout time, and by 2013,
there were about 700,000 microcontroller boards that were sold from the
Adafruit Industries alone, a New York City supplier of these boards. While there
were some issues that come with the trademarking of the Arduino, which ended
up with a split inside of the company for a few years, Arduino is now going to be
one single company that has devoted itself to the development of software and
hardware that is usable by the average person, while still having enough
flexibility in it to interest professional engineers.
What is Arduino?
This history is going to sound a bit convoluted right now, but the good news is
that this is not as difficult as it may seem in the beginning. We are able to go
through and learn a bit more about the Arduino system and what it is able to do
for us, through this chapter.

The first thing that we need to take a look at here is how this process works. You
will first need to purchase the hardware that you think is going to be the most
appropriate for your goals with this. And then, using a powerful computer with
the Windows, Linux, or Mac operating systems, you are going to write out the
codes and instructions for the board, and then upload it with the instructions
through a cable. The code is then going to be stored on a microcontroller, and it
is going to be able to function according to the instructions that you originally
sent over.

You are able to write any kind of instructions that you would like on this kind of
board. You could have it do something such as start-up a sound of beeping when
board. You could have it do something such as start-up a sound of beeping when
there is some light that comes through a door. The light activates a sensor that is
going to then connect back to the microcontroller, just like an alarm. This is just
one of the ways that you are able to use this kind of controller, and you are
basically able to set it up to take any of the codes that you would like.
Who Works with Arduino?
We also need to take a few moments to take a look at who would use Arduino in
the first place. There are many people who may use this controller for their
hobbies and projects, as well as some professionals who will work with it as
well. Because this is a program that is straightforward and simple enough for
beginners, and rich enough so that the beginner can grow enough in their skills,
later on, it definitely has gained a lot of popularity over time.

There are a lot of people who are going to work with the Arduino system.
Teachers and students will often use this, and indeed this is means to be the main
consumer base of these products. They were designed to be a low-cost method
that helps us to build up some scientific instruments so that students and teachers
are able to practice, as well as demonstrate, physics and chemistry principles,
while also getting started with things like building and programming robots if
needed.

In addition, it is possible that architects and designers are going to work with
these kinds of technologies as well in order to build up some interactive
prototypes and models early on, giving them an idea of how things are going to
work when they try to develop them on a full-scale. Artists and musicians are
even able to work with these controllers to help them do some experimentation
with new instruments and techniques that are in that art form.

Basically, what we are saying here is that pretty much anyone is able to work
with Arduino. Even if you have the most basic of skills when it comes to coding
at all, you will find that this controller is set up for anyone and everyone to learn
how to use. Whether you want to tinker with computer hardware and coding, or
you just want to learn a bit of the basic of software and microcomputers the
Arduino system is going to help you to get all of this done.
The Advantages of Working with Arduino
There are a number of advantages that we are going to be able to see when we
decide to work with the Arduino system. This is why there are so many
programmers, both new and more advanced, who are interested in learning more
about how this programming tool will work. Some of the advantages that you are
about how this programming tool will work. Some of the advantages that you are
going to see when it is time to work with Arduino will include:

1. The biggest reason that these kinds of controllers were created in the
first place was that they were cost-efficient. Rather than $100 or
more of other boards, these boards are often going to be less than
$50, and the boards that you can manually put together on your own
are going to come at a cost that is even lower.
2. The Arduino environment, or the IDE, is going to work across many
different platforms overall. This means that you can use a computer
with Windows on it like any other microcontroller board would
require, but you can also work with the Mac operating system
computer, or a computer that is going to run with Linux will work as
well. This makes it easier to use any system that you would like
while working with the Arduino IDE.
3. The software that you would use with Arduino is going to be
considered open-sourced. The tools or even the strings of code that
you are going to use to instruct the controller on how to behave is
something that anyone is able to access. You don’t have to go
through the process of purchasing a license in order to use these
tools, making it easier for them to be used in an educational setting.
4. The tools that we are able to get with the Arduino software can be
extendable with the C++ libraries and the AVR-C coding language.
This means that when you have some more in-depth knowledge of
these languages, you would be able to expand out the technologies
and what they can do more.
5. The environment that you will use to code this controller will be
simple and clear to work with. You will be able to understand what it
is asking you to do and some of the steps that are needed, even if you
are brand new to the experience. This is going to make working with
this software so much easier overall.
6. The hardware is also open-sourced. Anyone who has the desire, and
the knowledge, would be able to find and even create the hardware
that they would like to use along with the Arduino software
programming in the environment of the IDE. even those who are not
experienced in designing circuits are going to be able to use the
breadboard in order to create their own circuit board with Arduino.

These are some of the basics that we need to know in order to get started with
using this kind of board for some of our own needs. With these in mind, let’s
using this kind of board for some of our own needs. With these in mind, let’s
dive into some of the other things that we are able to do with this, and see how it
is going to work for some of our needs as well.

Other Things to Know About Arduino

Before we end this chapter and move on to some of the other topics that we need
to know about Arduino and getting it all set up, we need to look at a few more
things about the Arduino system to help us really see why it is such a popular
system and why so many people are jumping on board with it!

The first thing that we need to know is that the biggest driving force that was
behind creating the controllers for Arduino was the idea of being cost-efficient.
Rather than being worth $100 or more like some of the other board's costs, an
Arduino board that is pre-assembled is going to be less than $50. If you are
brave enough to put one together on your own, you will be able to get it done for
even less money.

The IDE or the environment of Arduino, is going to work with a lot of different
platforms overall. This means that you would be able to work with not only a
Windows computer, which is what most of the microcontrollers out there will,
but you can also work with it just as easily on a Linux or a Mac operating
system. This is going to make it a lot more appealing because it opens up the
door to users of Mac and Linux systems being able to work with this process as
well.

The third thing that we need to focus on is how the software of Arduino is going
to work. This software is going to be open-sourced right from the beginning.
You will also find that the tools you need, and all of the strings of code that are
used with this one to help tell the controller what you would like it to do are also
accessible freely to anyone who would like them.

This can be a nice addition because it means that you are not going to need to go
through and purchase a license in order to use these tools. Whether you are a
teacher working with a group of students who want to learn how to program with
Arduino, or you would like to do this training on your own and figure out how to
do coding, you will be able to do all of this and more without some of the added
costs.

Then open-sourced tools that we just talked about are also extendable if you
decide to use the libraries of the C++ language and the AVR-C coding
decide to use the libraries of the C++ language and the AVR-C coding
languages. These are great libraries that have a lot of additional features that will
help you to get some of the coding that you want done if you know how to use
them. Those who have knowledge of coding and how to use the two languages
above will be able to benefit even more when they combine those languages and
libraries with their new knowledge about the Arduino board.

There is going to be some more depth to the software and the programming
features when you are able to add in the C languages, and a more dedicated
programmer is able to go deeper with this while being still straightforward in the
language so that those who are just doing this for fun or as a hobby will still be
able to stick with it and not get lost.

The environment in which a person is able to code for the controller is going to
be clear and simple to work with. This means that the IDE and the computer
program that you are using will be able to take the instructions that you are
sending over to the controller and turn them into a form that is easy and
straightforward, and won’t take an advanced degree in order to understand. This
can be a big issue with some of the other boards and some of the other things
that you try to do in programming, so it is a nice change here and will ensure that
the experience that you have working with software like Arduino is as smooth
and seamless as possible.

And finally, we need to take a moment to look at the hardware and how it is
open-sourced as well. The board technologies that come with Arduino are going
to be published under a license that is known as the Creative Commons license.
This is good news for you as you start to explore some more of the coding
options that you have, and you may find that you need to make a few easy
adjustments to some of the hardware, or add things to the hardware, to make it
work.

Anyone who has the desire, as well as some of the knowledge in order to get it
done, will be able to go through and create some of their own hardware to use
with the software programming that comes with Arduino, as well as the IDE
environment. Of course, you do not need to do this if you don’t want and the
programming is going to work fine without this. Even those who do not have
experience as professional circuit designers though will be able to use the
breadboard in order to create their own circuit board with the help of the
Arduino system.

There is just so much that we are able to do when we work with the Arduino
technology. It may seem a bit complicated in the beginning and it will be too
technology. It may seem a bit complicated in the beginning and it will be too
hard to work with or even understand if you haven’t been able to work with
programming in the past. But that is part of the beauty that comes with it. You
will find that this is a system and technology that has been designed in order to
handle any task that you need, while still being easy for students to learn in the
classroom. Even without a lot of experience in coding and programming, and
without a technical background, you will be able to get this down. And the steps
that we talk about in this guidebook will help to make this happen.
Chapter 2: The Key Terms to Get Started

There are a few terms and other important things that we need to spend our time
on before we dive into working with this kind of board. It is helpful to have at
least a little bit of an understanding of how this board is going to work in order
to really help us to choose out the right board, make sure that we are writing out
the instructions in code properly, and set up the microcontroller in a manner that
we are able to use so that the board works well.
The Anatomy of Our Board
The first thing that we need to spend some time here is the board itself. There are
actually quite a few parts that come with this board. The digital pins are first,
and these are going to be along the edges of most of the controllers of Arduino.
These are what we are able to use to help with input or sensing of a condition,
and the output, or the response that the controller is going to make to the input.
For example, the input that we want maybe that the sensor of light is going to
sense that there is darkness or that there is a lack of light. This will cause it to
close the circuit that lights up a bulb and that is the output. This works if we are
creating a nightlight to use.

On most of the Arduino boards that we want to focus on, there is going to be a
On most of the Arduino boards that we want to focus on, there is going to be a
Pin LED that will be associated over to a specific pin, such as Pin 13 on the Uno
of Arduino. This is the Pin LED that will be the only output possibility that we
will find built into the board, and it is going to help us with our first project of a
blink sketch, which we are going to get a chance to talk about a bit later.

The Pin LED is also a good one to use when we want to fix or otherwise debug
the code that we have written, ensuring that there are no longer any mistakes that
are going to show u in it. The Power LED is what the name implies. This is
going to be what will light up once we see that the board is either turned on or
receiving power. This is another thing that will help you to debug some of the
code that you have.

Now, on each of the boards that you are using, there is going to be the actual
microcontroller itself, which is going to be known as the ATmega controller.
This is basically going to be the brains that will run the entire board that you are
working with. This one is going to help us by receiving the instructions that you
send in and then acts in the right manner based on those instructions. If you do
not have this in place, then the board is not going to be able to function.

Then we move onto the analog pins that are going to be present on the opposite
edge of the board compared to the digital pins that are on the Arduino Uno. It is
an input that is found on the Arduino system. Analog means that the signal,
which is going to have an input that is not constant but will vary with time, such
as the audio input that you are waiting for. in the example of audio input, the
auditory input in a room is going to vary with the people of the room talking and
with all of the other noises that may find their way back in from outside of the
room in question.

The 5V and GND pins are going to be another part that we need to focus on
because they are used in order to create some additional power of 5V to the
circuit and to our microcontroller. The power connector that comes here is often
going to be near the edge that we see with the Arduino board, and it is going to
be what we use to provide some power to the microcontroller when it is not
plugged back into the USB. You can find the USB port can be used as our
source of power as well, but for the most part, we are going to find that the main
function of this is to transfer our upload the set of instructions that we have
coded, from the computer where you did the coding, over to the Arduino.

The TX and RX LED”s is going to be used to help us indicate that there is going
to be a transfer of information that will occur here. This indication of
to be a transfer of information that will occur here. This indication of
communication is what we are going to see when we upload our sketches from
our computer to the Arduino so that they are going blink quickly when they are
going to do the exchange. And then we have the reset button is going to make a
sound to help reset the controller to its factory settings and erase out any of the
information that we have been able to upload to the Arduino.
Other Terms with Arduino
There are going to be three types of memory that come with the Arduino system.
Memory is going to be any of the space where we are able to store the needed
information. To start is the flash memory. This is where the code for the program
that you write out is going to be stored. It is also going to be known as the
program space because it is used for the program automatically when we upload
this to the Arduino. This type of memory is going to remain intact when the
power is cut off, or when we turn off this board.

Then we have the static-random-access memory or the SRAM. This is going to

be the space that the program or sketch you have created is going to be able to
create, store, and work with information from the input sources to give you the
output that you need. This kind of storage is going to disappear once we turn off
the power.

EEPROM is going to be similar to a tiny hard-drive that will allow the

programmer to store information other than the program itself when we have
turned off the board. There are going to be some separate instructions for this to
help out with reading, writing, and erasing, along with some of the other
functions that we need to use.

There are going to be certain digital pins that are going to be designated out as
PWM pins, meaning that they are going to be there to create an analog with the
help of some digital means. Analog, as we should remember, means that the
input or the output is going to be varied, and we are not going to see a constant
with this one. Usually, we are going to see that the digital pins are only going to
send out a constant flow of energy. But when we work with the PWM pins, they
are able to vary the pulse of energy that we see between 0 and 5 Volts. Certain
tasks that you are going to try and the program can only be done with these
particular pins.

In addition, when we are comparing the boards of the microcontrollers, we will

want to take a look at the speed of the clock because this helps us to see the
speed that this controller should operate at. The faster the speed that we see, the
speed that this controller should operate at. The faster the speed that we see, the
more responsive the board is going to be. Keep in mind that this is also going to
mean that more energy and more battery are going to be used up as well.

We can also take a look at something that is known as UART. This is going to
be responsible for measuring out the number of serial communication lines that
the device is able to handle. These lines are going to be the lines that are able to
transfer the data serially, or in a line, rather than sending them in simultaneously
or parallel. It is going to require us to use a lot less hardware in order to process
things in this manner compared to some of the others.

For some of the projects that we want to focus on, you may end up needing to
connect your Arduino device to the Internet of Things, which is going to help us
to describe the interconnectedness of the devices, other than a laptop or desktop,
to other networks that are out there that will share information. Everything from
smart TVs, smartphones, and even smart fridges are going to be connected to the
Internet of Things so it is a good idea to learn how to work with your Arduino
board with these.
Chapter 3: How to Set Up Arduino

Now that we know a bit more about the Arduino system and what we are able to
do with it, it is time to choose and set up the board that we want to work with.
The first step with all of this is to help us to choose out which board, out of the
many choices, that we would like to work with.
Picking Out Our Board
The first thing that we need to take a look at is which of these boards we want to
spend our time on. When we are looking through some of the options that come
with these boards, there are a few factors that we need to consider before we
make a choice. One of the biggest determining factors that we may have to
consider here is how much power we will need in order to run some of the
applications that we have in mind.

You may not know ahead of time the exact measure of the flash memory and the
processing power that you need for your project. But you will be able to tell that
there is a big difference between making a simple nightlight that is able to
change up colors and even flash compared to working with a robotic hand that
has a ton of parts that are able to move. The latter of the two is going to require a
has a ton of parts that are able to move. The latter of the two is going to require a
controller board that is more robust, that has a faster processing with it, more
flash memory, and more SRAM than the other choice.

Having this in mind is going to make it easier for you to figure out which options
on the board are going to be right for you. You have to first look at the amount
of power that you are hoping to get out of this board, and then work from there.

Then we need to move on to how many pins, both analog and digital, you are
going to need with your board to make it work for that project. Just like with the
other option, you do not have to be specific, but knowing whether you will need
just a few pins or quite a lot of them will really make a difference in which board
you are going to choose in the first place.

if you are working with a simple project just starting out, you may find that
having fewer of the analog, digital, and PWM pins can help us out here, but you
may find that with some of the more complex options that we are working with,
you will want to go with a board that has more pins to help you get done. You
have to have a good idea of what is going on with your project in order to see
results.

We can then consider whether or not we would like to work with a wearable
device or not. This is not going to make the whole decision for you, but it can
help you to narrow down the search a bit depending on which device you would
like to go with.

We talked about this a bit before, but you also have to consider whether you
would like to see this device connect back to the Internet of Things or not. If you
would like to connect to the Internet of Things, your work is going to be made
easier with a few other features. But not all of the boards that we are going to see
will have the features that we need to make this happen.

We have to make sure that the board that we are getting is going to have the
capabilities of the Ethernet connection, and the capability to connect to the
internet. This ensures that we are able to connect to a network like the Internet
and share data or interact with and control some of the other devices that are
going to connect with this as well.
Getting Started on the IDE Arduino
The software that we are able to work with the Arduino is going to be done on
the environment that is known as the IDE. This means that you will need to
the environment that is known as the IDE. This means that you will need to
either download the desktop IDE to do the code in or you can code online with
one of the online versions of the IDE>

The first way that you would try to access this IDE to do some of the codes is to
download the application that works on your desktop computer. There are going
to be a few different options that you are able to work in order to suit the devices
that you plan to work with. First, there is going to be a desktop application that
works with Windows. You are able to access this from a phone or tablet of
Windows with the Windows application when you are ready to make it all
happen.

Then we are going to see that there is a version of this that works with the Mac
OSX, which means that you will be able to get the IDE to work with all of the
desktops and laptops that come with Apple, but will not work on the Apple
mobile devices.

There are also going o be three options that you are able to use when it is time to
work with the Arduino IDE on Linux. This could work on the Linux ARM, 64-
bit and 32-bit versions. If you prefer to go with the option to work with the web
browser option, you can just head to the main site of the Arduino IDE and get it
to work from there.

When you get started with this process, you are then able to download the
version of the desktop IDE that you would like to use. You can then run the
application for the installation, click through the different options that are
presented, and before you know it, you will have the Arduino IDE up and
running in no time.

This is helpful because it is going to allow you to have access to the IDE and the
other software that you need to work with one of these processes. You can also
run it from a lot of different sources based on how you want to work with this.

Coding a Program on Arduino

The next thing that we want to work with is making sure that we are able to
write out some codes for this Arduino boards. We will spend some time covering
how to write some of these codes for the board later on, but for now we want to
learn a bit more about how to understand that the code is written in the IDE on
the computer that we have, or on a phone or on a table and that it can work on
either applications whether it is the web or desktop application. This allows you
either applications whether it is the web or desktop application. This allows you
to go through and see the entire code at once, allowing us to remove the right
errors and debug the program.

Once we have had some time to write out the code, we will need to make sure
that we are able to run it, and then debug or troubleshoot any of the errors that
show up with this. You will find that the best way to do this is to apply the
programs that you are coding to the board of the Arduino, and then seeing if it is
going to run. And that is where the next step of the process is going to come in.
Connecting to Our Arduino Board
Now, when you are taking a look at some of the boards that we have, you may
notice that some of them are going to have some kind of USB ports with them.
To get started with this one, we just need to take the right end of the USB cord
and plug it into our computer, and then the other end of that USB port into the
board that you will like to work with.

When you do this, you will find that the IDE software that comes with Arduino
is going to recognize the type of board that you are working with automatically.
If this does not happen then you just need to go through and chose the correct the
board from the dropdown menu.

In addition to this, you will also need to use, in some cases, the TKDI cable or a
breakout board to help make sure that this board is going to be compatible with
the computer that you are using. This means that we will need to go through and
insert the TKDI into the right port on the controller board. If you are able to
connect the TKDI cable to the breakout board, you will be able to do it in the
same manner that you did with the USB. Again, the software program that you
are using with Arduino should be able to recognize the board, but you are also
able to choose this from the menu in order to have this happen manually.
Uploading the Arduino Board
To help us to work with uploading the sketch and the code that you already
created, you will first need to go through and pick out the right port and the
board that you would like to upload all of this too. It should be a pretty simple
process to go through and select out the right board, as you will simply need to
look for the board title that is going to match up the name of the board type that
you are working with. To help us to go through and select the right serial port,
you have a few options to make this happen, including the following:

For a Mac computer, we are going to have two options. If we are working with
For a Mac computer, we are going to have two options. If we are working with
Leonardo, Mega2560, or Uno, we are going to use the code below:

/dev/tty.usbmodem241

But if you are working with the boards that are Deumilanove or some of them
even earlier boards, you will use the code below:

/deve/tty.usbserial-1B1

For all of the other options that are going to be connected with the adapter that
works from USB to serial, you would work with the following option:

/dev/tty.USA19QW1b1P1.1

Then we are able to move on to working with a Windows operating system and
how this will work for some of our needs. If we are working with a serial board,
we are going to work with either COM1 or COM2. If you are working with a
board that is connected to a USB, you will want to work with COM4, COM5, or
COM7 or higher. You should look inside of your Windows Device Manager to
help you to determine which port on that board or device that you are using and
then go from there.

Then we can also work with the Linux system as well. If you are going to hook it
up with a serial port, you will use the code below:

/dev/tty.ACMx

If you would like to use the board for something like a USB port, you would
need to use the code:

/dev/tty.USBx.

Once you have been able to go through and select the right port and board for
your needs, you can then go through and click on Upload, before choosing
which Sketch you would like to upload from the menu that shows up. If you are
working with a newer type of board, you will find that it is a simple process to
just upload the new sketch. But when you are working with some of the older
boards, you need to take a moment to reset the board before you are able to
upload a new sketch. If not, you could end up with two sketches that could
conflict with one another on the memory of the board, and this can cause it to
crash overall.
How to Run Arduino with Your Program
How to Run Arduino with Your Program
Now it is time for us to take a look at how we are able to run the Arduino
software with your program. There are a few ways that you are able to power the
Arduino board once the code that you programmed is on it. The first method is
to power it with the connection of the USB to another device that is powered,
such as to your computer. A second method is to power it with the help of an
Ethernet that the board is compatible with. This means that by connecting to the
necessary network, you are going to be connected through the source of power
that you need with the Ethernet. And finally, you are able to power most of these
boards with a battery that is lithium polymer.

Once you have been able to get the power all connected and ready to go, and you
have the right input that you want to use put into that microcontroller, you will
be done. Everything is going to perform the function for which it is intended and
you can use the board.
Chapter 4: The Starting Point for Coding in Arduino

At this point, we know how to get started with the Arduino board, it is time for
us to look at some of the simple parts of the coding that we are able to do with
this kind of language. Coding a program with Arduino means that we will need
to go through and write out a new language. The good news is that it is not
always going to be as hard as you may think, even if you are brand new to the
process. In the same way that we are going to see mathematics has its own set of
symbols that are going to denote some of the different functions like
multiplication and addition, there are going to be some different symbols and
terms that you are going to need to work with when it comes to Arduino.

If you have had some time to experience coding in the past, you will find that
this language is going to be pretty simple. For those who have never had a
chance to learn how to code, translating one form of code is going to be similar
to translating one language over to the other. Though this is something that is
going to seem a bit difficult to get started with, the idea of coding is to make
coding for some of the other programs easier later on.

You do not need to worry if you are just getting started with coding and you are
You do not need to worry if you are just getting started with coding and you are
not sure how to get started. we are going to go through now and look at some of
the words and terms that we should know when it comes to coding with the
Arduino IDE and how we are able to work with all of the different parts.
The Structure
The first part of this is how to set up some of the structure that needs to be found
in this kind of coding language. We will start out with the setup() method. This
is the function that we are going to call out when the sketch starts. And it is only
going to run one time after we do the startup or when we reset the board. You
are able to use it for several different things, such as starting variables, pin
modes, or for use with some of the libraries. There are also a few other terms
that we are able to use when it is time to add in the extra functionality that we
need.

Then we need to work with the loop(). The loop function will require this
controller board to go through and repeat the function that you set up more than
one time. it can go on continuously until a certain condition or variable is that
you set is actually met. We are going to set the condition so that it is going to
stop the loop, or you will essentially freeze up the program that you are working
with and you will need to turn the board off to get it to stop.
The Control Structures
The next thing that we need to spend some time here is the control structures.
These are important because they will show us the manner in which we are
going to receive a certain input. Just like we can guess with the name, there are
going to be various inputs regarding control that we can use in order to
determine how the data is going to be readout. Provisional language is also going
to be considered when it comes to how it analyzes the data that we have. some of
the different control structures that we are able to use in Arduino and other
languages are going to include the following:

The first option is the if statement. This is what will help to link together a
condition or an input to the chosen output. It means that if a certain condition is
met, then a specific response or output from the controller is going to happen.
For example, if the thermometer that is attached to our control gets higher than
75 degrees, you might write out the code to tell the board to send a signal to your
air conditioning unit so that it is going to turn on to decrease the temperature so
that it goes back to the 75 degrees.

Then we can move on to the if else statements. This is going to be similar to the
Then we can move on to the if else statements. This is going to be similar to the
conditional of if that we just took a look at, but instead it is going to specify
another action that the controller is going to take if the condition for the first
action is not actually met. This is going to make it possible for you to get two
different actions to happen in two different circumstances with just one code that
you are writing.

Then we will look at one of the loops that we are able to write. We can look at
the while loop, which is one that will continue on indefinitely until the
expression that it is connected to is going to be false. What this means for our
goals is that it is going to perform a certain function until the parameter is no
longer met, and then the statement that is going to be in charge of the condition
that you made is going to be false.

Along with the while loop, we are going to be able to take a look at the do while
loop. This is going to be similar to the while statement, but it is going to make
sure that it runs through the condition at least one time before it ever tests out the
variable at the end of the function, rather than doing it at the beginning.

We can also work with the break function. This is going to be kind of like an
emergency exit from the function that your controller is working with. This one
is going to be used to exit the do, for, or the while loops, without actually
meeting the condition that you set up and asked to be met so that you can exit
that part of the functionality.

The return function is another good one to spend some time on. This is going to
be one of the best ways to help us to stop a function, and if it ends up returning
to us a value with which the function is terminated to the calling function, or the
function that is asking for that information in the first place.

And finally, we are going to end up with the go to function. This is going to be a
function that will tell the controller that it needs to move to another place, but
not in a consecutive location, in the coded program. It is going to transfer the
flow over to another place in the program. It is going to usually be discouraged
by those who work with the C language programming, but it can, in some
situations, help to simplify the program that we are working with overall.

The Syntax
There are a few parts of the syntax of this code that we need to spend some time
to ensure that we are going to see some of the best results as well. Some of the
to ensure that we are going to see some of the best results as well. Some of the
parts of the syntax that we need to spend some of our time on will include:

1. The semicolon: This is going to be used as a period in the English

language because it is going to help us in coding to end the statement
that we are on. We need to make sure that the statement that we close
up with the semicolon is actually complete, or the code is not going
to work in the manner that we want.
2. Curly braces: These are going to have a lot of functions that are more
complex, but the thing that we need to know is that when you insert
these in the beginning, you have to follow it up, at some point with
curly braces to close it up. This will ensure that the braces we are
working with will remain balanced and can be really vital to making
sure that the program is working.
3. // or a single line comment: If you would like to set a reminder for
yourself, or to tell another person about how the code is going to
function, then we need to use this code to begin the comment. Make
sure that with this one that we are only taking up one line at a time.
this is not going to transfer over to the processor of your controller,
but will be live in the code, and can be a good reference to you, as
well as to anyone else who is manually going through the code:
4. /* */ or a multi-line comment: This type of comment is going to open
up and can span past more than one line. it is going to contain just a
single line comment but is not going to contain another multi-line
comment as well. Be sure to close with the other part of the process,
or the whole of the code that comes after this is going to be seen as a
comment and it won’t be implemented for you.
5. #define: This is going to help us to define a certain variable as a
value that is constant. It is going to give the name to value as a sort of
shorthand for this kind of value. These are not going to take up any
memory space on the chip that we are using, so it is a great way to
conserve some of the space that we have. once we have been able to
compile the code, or we take it with a program, then the compiler is
going to replace any of the instances that we have with a constant as
the value that was used originally to help define it.
6. #include: This is going to be used any time that you would like to
include some other libraries into the sketch that we are working with.
This means that you would be able to use this to include other coding
languages and words into the sketch that would not automatically
 show up there. for example, you may decide that it is a good idea to
include the AVR C libraries or some other tools and codes that we
are going to need from the different libraries that come with the C
language.
a. One thing to note with this one is that you should not go
through and add in a semicolon at the end of this
statement, as well as the #define statement that we talked
about before. If you do end up adding in a semicolon to
close up this one, you are going to get an error message
and you will find that your code is not going to work the
way that you would like.
The Data Types
Now we need to move on to some of the types of data that are found with this
kind of language. The data types are going to refer to some of the different types
of data that are received in each of the programming setups that you want to
apply. The data that you can receive by this system is going to be sent over to the
program that you choose in order to determine the different outcomes. Some of
the most important types of data that we are able to work with will include:

1. Void: This is going to be used in a type of function declaration to tell

your controller that you are not expecting any information to be
returned along with the function.
2. Boolean: This is just going to be able to hold onto one of two values,
either true or false. This could be true with any of the functions that
are available. You would work with && if you want to have two
conditions that are true at the same time that the Boolean is true, or ||
if you want to have one of the two conditions to be met, either one
setting off the output response and ! for not true, meaning that if the
operator is not true, then the Boolean is true.
3. Char: This is going to be some kind of character that is found in your
code, such as a letter. It can be numeric as well. You are often going
to have strings of characters that work together to handle the different
things that you want to work with.
4. Unsigned char: This is going to be the same as the character that we
just talked about, but it is going to focus on the numbers 0 to 255 to
help signify characters, rather than the signed characters which can
potentially include some negatives.
5. Byte: This is going to be one of the data types that are able to store a
 number that goes from 0 to 255 in an 8-bit system of binary numbers.
6. Int: These are integers and are the main way that you are going to
store the numbers that you have.
7. Word: A word is going to be able to store a 16-bit unsigned number
on the Uno and on other boards that you want to work with. When
you are working with Zero or Due, you will be working with 32-bit
numbers with the help of words. This is basically going to be the
main way that you will store your numbers and integers.
8. Float: This kind of number is going to be a single-digit that is then
followed by up to 7 decimal places, and then multiplied by 10 to a
power of up to 38. This can then be used to help us to store some
more precise numbers, or at least some larger numbers. These are
going to end up taking a lot more processing power to work with, and
they are only going to have a precision that is up to 7 decimal points
so they may not work on everything.
9. Double: This is something that is only going to be relevant when we
are working with Due, which will allow us to get some double
precision when it comes to a float number. For all of the other boards
that we are going to use in Arduino, we will find that the floating-
point is going to take 32 bits, so floating is not going to do anything
to help these boards to increase their accuracy or precision.

These are some of the basics that we need to know when it is time to work with
the Arduino language and we want to make sure that we are able to write out
some of the other codes that you want to do for your programs. Learning these
basics and what we are going to be able to do with this process can help to
ensure that we are able to get the most out of this board.
Chapter 5: Turning Your Arduino Into a Machine

While the buttons and switches that are found with this kind of board are going
to be great things to work with, there is still a lot more than you are able to do
with the board outside of turning it on and off. Although Arduino is going to be
a digital device, it is able to receive information from an analog sensor so that it
is then able to measure things like the temperature around it and light. There are
also different inputs and programming languages that will end up giving you
different results, so the outputs that we are going to see with this will often
depend on the sensors and the coding that you want to choose.

You will be able to find more of these sensors for the board on the official
Arduino website. To create all of this though, you would want to use the built
Analog to Digital Converter of the Arduino. You will use a temperature sensor
in some cases when you want to determine the warmth of your skin. This kind of
device that we are using is going to release a changing voltage based on the heat
that it is going to detect.

For this one, we are going to be able to find three pins to help us get it done. The
first pin is going to connect to the ground, while the other is going to connect to
the power. And then we have the third pint that is able to transfer the voltage of
the power. And then we have the third pint that is able to transfer the voltage of
the variable over to the Arduino. This project is also going to come with a sketch
that is going to help us to interpret the sensor and then turns on our LED’s, and
turns them off, by displaying the warmth level that it is going to see. The
temperature settings and sensors are going to come in different types. The
TMP36 will often be the method that you want to work with because it is going
to show us a new voltage that is going to be different from what we are able to
get with Celsius.

The IDE of the Arduino features a serial monitor device that will allow us to
record some of the results from some of the controllers. Using the serial monitor
helps one to discover information that is related to the status of the sensors, and
can help us to develop more knowledge about the circuit and the code that we
need to run for the program to work.

Create the Circuit

Now, we are going to go through this and work with is manually, but we are able
to achieve this with calibration. We are able to use the button that is needed to
define the reference temperature or to let the Arduino before the loop starts and
then have that as the point of reference that we want to work with. Some of the
steps that we need to work on to make this happen includes:

1. First, we need to connect the breadboard that we are using to the

ground.
2. Then connect the cathode of every LED that we have to the ground
with the help of the resistor. Join the anodes of the LEDs to pins 2
using 4. These are important because they are going to be the
indicators of the project.

From there we want to be able to position the TMP26 to the breadboard by

letting the rounded part face away from the board that you are using. Then you
need to joint he flat facing side of the left pin to the power, and then the right pin
over to the ground. We can then connect the central pin over to the AO on the
Arduino we are working with.

The next step that we want to focus on is building up an interface for the sensor
that will make it easier for the users to work with it. You can even work with a
cutout of paper that is going to resemble the human hand if this helps you to get
this done. If you are right with it, you are able to build up a pair of lips for a
person to kiss, and then note how this is going to look. You might also need to
person to kiss, and then note how this is going to look. You might also need to
spend some time to mark out the LED’s so that you can get the meaning out of
them.

So, to start with this, we want to get a piece of paper and then cut it in such a
way that it is going to fit right over the breadboard. We can then create the lips
where the sensor should be placed, and leave a few circles in here so that the
LEDs are able to go through the process. From there we are able to cover up the
cutout of the lips on the breadboard so that the lips you are using will surround
the sensor and the LEDs in the holes. Then press the lips to see how this is going
to feel.

When we get to this point, it is time to help us to examine the code that we need
to use to make this happen.
The Useful Constants
Constants are important to what we are working with, you will find that they are
going to give some unique names to the things that are found in the program.
This is going to be similar to the variables that we may know in other languages,
but they are not going to be able to change. We need to assign the name for the
analog input for easy referencing and then create a new and unique instance that
is going to help us to store the temperature that we want to use as the reference.

For each degree that we find to pass the reference temperature, the LED is going
to be able to switch on. The temperature is going to be written and then stored in
a floating-point number, and this one will only be allowed to hold onto one
decimal point overall.

In the next step, we need to work with the initialization of the serial port. With
this one, we are going to interact with a command that we have not seen before,
which is going to be known as Serialbegin(). This command is important
because it helps to begin the connection between our computer and the Arduino
board. The link is going to help us to read over the values form the analog input
onto the computer screen.

The argument of 9600 is going to represent the speed of communication that

happens with Arduino. You will be able to use the serial monitor of the IDE that
comes with this in order to help us to observe the information that you would
like to pick out and then send it from the controller.

Then we need to work on initializing the digital pin and switching it off at the
Then we need to work on initializing the digital pin and switching it off at the
right time. this is going to be useful when we work with the for loop that can set
the few pins to be the output. These pins were the ones that we have connected
to the LEDs in the first place. Instead of assigning each of the unique names and
using the function of pinMode(), you are able to use them for a loop because it is
more efficient. This is going to be a really good trick to work with in case you
have many things that you are hoping to get to repeat through the program that
you are working with.

At one point, we want to be able to have the sensor come up with a temperature
and we want to be able to read it. While in the loop from above, we want to work
with a new variable that is going to be known as sensorVal in order to hold onto
the sensor reading for us. If you would like to be able to read the sensor, you
would need to go through and call up the analogRead(), which is going to accept
just one single argument.

This is not the only thing that we need to get done here though. We need to be
able to go through and transfer the values of the sensor over to our connected
computer. The function of Serial.print() is going to help us to take the data we
have of the sensors of the Arduino and move them to the PC. You are able to
check this information with the help of the serial monitor.

If you had gone through this and assigned the Serial.print() a parameter in the
quotation marks, it is going to show up here as the text that you typed. In
addition, if you use a variable as your parameter, it is going to show us the value
of that variable in the first place.

Then it is time for us to go through and convert the sensor reading into a voltage.
With some knowledge of math, you are able to go through and determine the
right pin voltage that you want to work with. The voltage can range from 0 to 5
volts and has some fractions that are going to show us as well. It is important to
remember that you will need to go through and declare a float variable in order
to get it stored where you would like.

Then it is time to change the voltage over to temperature before it gets loaded
onto your computer. The datasheet that you see with the sensor is going to have
information that is similar to what we see with the voltage of the output. The
sheets of data are going to be like electronic manuals. They are going to be
created by engineers to be used by other engineers in the process.

According to these sheets of data from the sensors, every ten millivolts is going
to equal about 1-degree change in Celsius. In addition, we are going to need to
to equal about 1-degree change in Celsius. In addition, we are going to need to
go through and define an offset for some of the values that happen when you get
below what is considered the freezing point. If you are minus 0.5 from the
voltage, and then multiply by 100, you are going to be able to get the actual
temperature in degrees Celsius for this.

If you have a low temperature here, you may decide that you would like to turn
off the LEDs when this happens. When you are working with the original
temperature that we start with, it is possible to define an if else statement to help
turn on that light. By using this as the reference temperature and the point to
work with, you are going to switch on the LED after you see a change of 2
degrees in temperature. You will be able to scan through this for a range of
values as we look through the temperature scale.

The next step that we need to spend some time on here is turning on the LED to
create a low temperature. The && operator is going to stand for the “and” in the
logical sense. The point of working with this is that it will allow us to check out
whether there are multiple kinds of conditions going on in the process.

But then maybe we want to work with the process of creating a medium
temperature that is going to turn on two of our LED lights. When the
temperature falls down a bit, somewhere between two and four degrees above
the baseline, then the block of code is going to turn on the LED that we will see
with pin 3.

This is just one of the examples that we are able to use when it comes to working
with some of the coding that we can do with the Arduino language. And when
we are able to combine it together with some of the information and coding
basics that we are going to see with the C language, like we will do later on in
this guidebook, you can add in some more of the functionality that you are
looking for in this board.
Chapter 6: What Do I Need to Know About the C
Language.

The next thing that we need to spend some time on here is how to work with
some of the functions and basics of the C language. When you are ready to
create one of these programs, it is going to be essential for us to have some
knowledge when it comes to the working computer systems even though the C
programming language is going to be the one that is used with a lot of machines.
You will find that as we work with this language, how certain things are going to
be done when the program runs will often not be as clear until they actually run.
The instruments that are going to work for and with Arduino, such as the LEDs
and the sensors, are going to depend on specific inputs and outputs. And many of
the program languages are going to have the ability to handle this, but C is the
one we are going to focus on.

A primary system is going to consist of the control device, which we are able to
refer back to as the CPU or the microcontroller that we were talking about
before. There are going to be some differences when it comes to a few of these
that we would use. We shall look at this a bit later. But, keep in mind that these
controllers are not going to be as powerful compared to what we see with a
standard microprocessor. It is still going to contain the input, the output ports,
and the hardware functions that we want.
and the hardware functions that we want.

You will find here that the microprocessors that we are talking about are going
to be connected back to the external memory. Generally, the controllers are
going to contain the right amount of memory onboard. However, when we say
this we are not really talking about the larger sizes. It is possible for the
controller that we are using with Arduino to have only a few hundred bytes or so
of memory for some of the simple applications that it uses.

The register is going to be the only place where we are able to have logical-
mathematical operations that we would like to carry out. for example, if you
would like to carry out an example of the addition of two variables, the value of
these variables is something that we are going to need to move over to the
register.
The Memory Maps
Each memory byte that is on the computer system is going to come with their
own connected address. Now, if we do not have this kind of address in place, the
processor is not going to have the means that it needs in order to identify the
memory that we want. In general, the memory address is going to begin from 0
and then will increase from there. even though we are going to have addresses
that are more specific with a private or a unique system, a particular address may
not point to the input or the output port when it comes to communication that is
external.

For the most part, you will find that it is going to be necessary for us to do a map
of the memory that we have. this is going to be a massive array of the slots of
memory that we are working with. We have people who will spend a lot of their
time developing these maps and will have the address with the least value
positioned at the top while others who draw the map and assign the least address
to the bottom will be there as well. Each of the address points to a place where it
is able to store some of the bytes that comes with the memory as well.

In the following chapters, we are going to find that there are a few things that we
will be able to do in order to handle the C language. This is some of the basics
that we are going to be able to use with this, but we will want to make sure that
we get through some of the statements and more that we need to accomplish
with this language as well.
Chapter 7: Looking at Logic Statements

The first circuit that we talked about before was pretty basic, and it was able to
provide us with some output about what is happening without any possibility
that the user is going to be able to go through and change up some of the
conditions. When it comes to an input being able to affect the output, we are
going to then start to enter into the place of logic statements.

These logic statements are going to be one of the best ways that you are able to
check out the value of a variable, against some other value that we have. this
other value is going to depend on what we want to compare in the process, but it
could be a variable or a known quantity. Using these logic statements is going to
be how we are able to gain some control over what is going to happen next in the
sketches that we are working with.

To follow along in this IDE of the Arduino, the path that we need to work with is
going to be File, Examples, 02. Digital, Button.

Notice how similar the code above is going to look to some of those that we did
at the beginning of this guidebook. I’m sure now that you are getting a good
understanding of what is going on in these codes, especially since we are able to
see that it is code that is easy to read. Even with this in mind, we are going to
see that it is code that is easy to read. Even with this in mind, we are going to
spend a bit of time breaking down some of the new elements that we have not
had the time to look at yet.

One of the variables that we are going to spend our time on will have to do with
the pin of the button, and the other is going to include the state of the button.
This can tell us whether the button is on or off. When we were in the setup
mode, we were working with the pinMode to help initialize these pins. But for
this situation, we are going to have the button pin with the direction of INPUT,
which is going to tell the chip that this current is going in rather than going out.

Now, when we are doing this with a loop, we are going to get into a real
program, and then the first line is able to introduce another function to help us
get things done. In this, we are going to work with digitalRead(), which is going
to be the counterpart that we are going to see with digitalWrite() that we touched
on a bit before.

This is also the place where we are going to encounter our first piece of Boolean
code along the way. This is going to mean logical statements. This is going to
mean that the outcome that we are able to see with this is going to depend on
whether or not there are certain conditions that are met. The command is already
going to give us the perfect condition and tells us this ahead of time.

We also need to check whether or not the button state has been pressed. When
the button is pressed, it is going to show us HIGH. The expression is an if
statement and that piece of code are only going to show up and work if it is
inside of the curly braces. This can help us to know whether it is going to behave
the way that we would like.

Next, we are going to see an else statement that has a set of curly braces as well.
Else means that if the last statement that you worked on is not true, then it is
going to execute the code that is contained within those curly braces. In our
current example, this is again going to work with digitalWrite() to help tell our
chip on the board that it is time to turn off the LED light, just like what we did
with the last part of the code.

One thing to note with this is while the sketch does come with an else statement
here, it is not required for all of the sketches that we have, and you will not need
to work with the if statement and provide an else statement along the way.
instead, you could set it up so that if the condition is not met, the code is not
going to run and the next instruction is not going to be shown. This is going to
going to run and the next instruction is not going to be shown. This is going to
work depending on what kind of code y u are trying to work with.

With this in mind, we need to take a look at how we are able to take the Arduino
board that we are working with and get it to blink at the push of a button. There
are already a few of the simple circuits that we are able to choose from, but then
we need to take a few moments to help us to get this done. To follow along with
this kind of project, we need to open up:

File → Examples → 0f.Control → WhileStatementConditional

The first part that we are going to be able to get out of this sketch is something
that should look pretty familiar to what you are doing. We are going to go
through and declare the variables that we are going to need, initializing them,
and then setting the pins to help correct the settings which are going to be either
the output or the input. Once we hit the main loop that comes with the program,
we are then going to be able to get a bit of experience with what our while
statement is going to look like. Some of the code that we need to work with this
includes:

while (digitalRead(buttonPin) == HIGH( {

​ calibrate();

This statement is actually going to have a lot of information inside of it, even
though we haven’t written out that much, so we are going to take a moment to
explore it all and see what it is able to do for us. To start with, while statements
are going to mean something when they are inside of the curly braces, as long as
the condition that we are working with is going to be true.

So, then we need to take a look at what the condition is in the beginning. If the
button is getting pressed is toing to be our condition. So, we will need to check
the pin that is associated over to our button to see if it is high or pressed. If that
is true, then it is going to calibrate, which is a function that the user will have a
change to define at a later time. What this is going to mean for us is that when
the program sees that you have the command of calibrate); it is going to jump to
the instructions that you set for that function, execute them, and then go back to
that part of the code.

We can also spend a bit of time looking at this particular function since this is
what is being called at the time. We are going to take a look at the void
calibrate() } part of the code.
At the beginning here, it is going to look familiar because it is going to be
similar to the loop() and the setup() functions that we were using already. What
this line of code is going to tell the compiler is that you would like to be able to
define a function with the name of calibrate, and then it is going to return the
void to you, which shows no argument.

But what is all of this going to mean. First, we are going to see that defining the
calibrate means that if we type in that same word into the code in another part of
the code, the compiler is going to search for a function that has the same name,
and will run it like we are working with right now. But what about returning the
void that we have there.

We haven’t really had a chance to touch on this yet, but we are just taking the
loop for granted at this point for now. This function does also work, but it is not
always going to be the case when we add in the void work. When a function is
able to complete the instructions that you place into those curly braces, it is
going o return to us a value that is called the function in the first place. This can
be in the form of a no return or a void, but it could easily be a number or an
integer form the calculation that we are working with.

For this one, let’s say that this function, instead of calculating out the weekly
earnings of the people who work for a company, it is going to work with a
floating number that will contain the value of those earnings to be used in
another place of the program. What would this kind of function look like as
well? This is definitely something that we are going to be able to focus on and
see some great results in the process.

There are a lot of logical expressions that we are able to use when it is time to
work with the Arduino language overall. Being able to make this work for our
needs, and learning how all of these are similar and different is going to make a
difference in the amount of success that we are going to see.
Chapter 8: The Operators

While we are on the topic of some of the cool things that we are able to do with
the Arduino language, we then need to spend some time on the operators. There
are a lot of operators that we are able to use in many of the various coding
languages that we want to focus on through this guidebook. But we will find that
there are going to be some differences in the operators that we are going to see in
this kind of language.

The operators are simply going to be some symbols that are used in order to
perform operations for getting things done. The operators that we are working
with in this language can be bitwise, logical, and arithmetic depending on what
you are hoping to get done in your code. Let’s take a look at some of the
different options when it comes to an operator in this language and how we are
able to use each one.
The Arithmetic Operators
As we have been able to see above, these arithmetic operators are going to be the
ones that we are able to use in order to carry out some of the mathematical
operations that we have. if you would like to add two numbers or parts of the
code together. We are able to add together, subtract, multiply and divide parts of
code together. We are able to add together, subtract, multiply and divide parts of
the code based on what you would like to see happen in the code that we are
working with.

You can even have more than one of these show up in the same part of the code,
and the same line. We simply need to remember to go with the order of
operations. This allows us to go through with multiplication, division, addition,
and subtraction. Going in this order will ensure that we are able to make the
process work the way that we need.
The Boolean Operators
Another option that we are able to work with in this language are going to be
some of the Boolean operators. These are going to be based on the idea that the
output you are going to get will either be true or false. There are going to be a
few different options that we are able to work with when we are in the Arduino
system including &&, || and !.

These are the two main types of operators that you will want to focus on when
working on this kind of board and making it work for some of the results that
you are looking for in the process. Learning how to make these happen, and
ensuring that you are able to get them to show up in the codes in the right
manner, and at the right time, will be important to the overall coding we are
doing.
Chapter 9: Getting Your Machine to Make Decisions

Now we are going to take some time to learn how we are able to take the
Arduino machine that we are working on and set it up so that it can make some
decisions for us. In the process of decision making, the programmer is going to
be able to specify the conditions that it would like to evaluate, and then test these
in a programmatical manner. The programmer is going to specify the condition
and then see whether or not it is true, and sometimes they will check to see if it
is false. Let’s take a look at some of the various options that you can come up
with when working with the statements that make decisions in your code.
The If Statements
The first option that we are going to take a look at here are going to be the if
statements. With these, we will find that the expression is something that we are
able to add into the parenthesis, and then we are going to follow it with one or
more statements based on what our code is looking for. if the expression is going
to be true based on the conditions that we set, then the statements are going to
run. Otherwise, we are going to see that nothing is going to happen. A good
example of the syntax that we are able to see with this includes:

if (your_expression)
 ​ statement;

We are going to find we are able to do a few things to make all of this happen.
The first option is to wrap up the sensor value so that it goes with a certain
frequency on the board to make it work the way that we want. To do this, we
would want to write out a code that is able to declare the variable that is the
pitch. This is going to be the value that is stored in the pitch variable maps from
our sensorValue. We also want to make sure that we define the sensorLow and
the sensorHigh to be the boundaries for the values that we receive while we are
going to use, for this example, 50 to 4000 as our starting output. We are able to
make some changes based on what works for us.

Then we can take this on a bit and look at the frequency of the playing. This is
going to be where we will call up the tone() function so that it is able to play the
sound that we want. This function is going to be helpful because it is going to
have the ability to accept three arguments. The pin that is going to be there to tell
us the sound, the frequency of playing, and then the time period that the
frequency should hold onto the note that we are using. We can also call up a
delay() function to help us to create any delay that we want, but mostly it is best
to keep this at ten milliseconds so that you are able to create a bit of time for the
sound to play out.

When we turn on the Arduino again, there is going to be about five seconds that
are needed to help adjust the sensor that we are able to use. To achieve all of
this, we need to make sure that we are able to rub our hands gently around the
Photoresistor by varying up the intensity that we will see the light that strikes to
it. Let the motion of your hands here be close to the instrument because it can
help to really improve the amount of calibration that you are getting.

When the five seconds are up, the calibration is going to be over, and the LED
on the Arduino is going to turn off. The next thing that we will want to work on
is to determine the noise that is going to come off of the board from here. When
the intensity of the light that strikes on your sensor change sup, the frequency
that you hear is going to have some variance as well.

The code that we are going to see here will include a function for map, which is
going to help us to define the pitch that we are working with as wide. And you
are able to go through and change up the frequencies that you want to work with
to help you determine which one is going to be the right one for any musical
style that you are working with.
We will also find that there is the tone function, and this one is going to work
with a manner that is similar to that pWM that we had earlier, but there is a
difference. With the analogWriter() that we talked about before, there is going to
be a fixed frequency that we need to worry about. However, the tone that we
have is going to continue to send out pulses when you try to send the rate.

On the other hand, we are able to work with the tone() function because it allows
us to define what frequencies are going to show up when it pulses a piezo or the
speaker. If you are able to apply some of the sensors to the voltage divider
circuit, you will not end up getting a range of values that are really complete>
you may find with this one though that calibrating the sensors is going to make it
easier to map out the inputs that you want, and puts them into the specific field
that we want.

There are so many ways that we are able to set up the board so that it is able to
make some of the decisions that we need all on its own. When we are able to get
this set up in the proper manner, and we ensure that we are able to work with this
properly and get it to fit in, we will find that this is going to be one of the best
ways to ensure that the board we are using, no matter what kind it is, is going to
be able to make decisions based on the input and the information that it is getting
from others that use the system as well.
Chapter 10: The Fun Stuff – Taking a Look at the
Sensors, Outputs, and Inputs

As we have spent a bit of time talking about earlier in this guidebook, you will
need to spend some time on some of your projects working with the sensors that
come with the Arduino technology. These sensors are going to provide us with a
lot of uses and functions based on what we would like to use them for. Arduino
is going to be designed so that it can be inclusive for many types of sensors,
which can, in turn them be applied to working with the C programming language
as well.

You will quickly find that when you work with some of the projects that are
available with these boards that Arduino is equipped to handle and work with
these sensors. And what is even better is that these are going to be relatively
cheap for us to purchase and use. With all of the options, it is sometimes hard to
know what kind of sensor is going to be the best, and some of the examples of
these sensors that we are going to spend our time on here will include:

1. The ultrasonic module.

 2. The soil hygrometer detection module that helps us to sense out the
moisture in the soil.
3. The IR infrared obstacle avoidance sensor module.
4. The Wi-Fi module
5. A accelerator module
6. IR flame detection sensor module
7. Speed sensor
8. Rain and humidity detection sensor
9. Motion sensor module that we are able to turn onto vibration when it
is using the alarm.
10. MQ-2gas sensor module that can help to detect the
smoke from methane butane.
11. Rotary encoder that will help us to brick sensory the
development board we are using.
12. Digital sensor for thermal things like measuring the
temperature that is around us.
13. Digital barometric pressure sensor board.
14. Microphone sensor.

Of course, these are just a few of the options that we are able to work with when
it is time to pick out the sensors that we want to use with the Arduino
technology. Some of the sensors are going to be able to connect you to the units
and parts that you need, and some are going to be a bigger challenge so it all
depends on what is going on with the work that you plan to do.
Why are Analog Signals Important?
Before we get into this too much, we need to spend some time looking at why
the analog sensors are going to be the most important. To start, analog inputs
like the voltage of some sensors are going to be the result of some changing
factors. For example, we may see that there is a photo resistor. This is going to
be an electrical resistor that is able to change up the value that it gives you based
on the amount of light that it gives. We are also able to measure the voltage on
this resistor using the multimeter.

It is also possible that we would go through and use this kind of phenomenon to
help measure any of the other environmental factors that we want, as long as we
make sure that there are enough strong sensors that convert the factor into analog
signals including things like light, temperature, power, and humidity.

We are going to see that it is possible to look at an example of how this is going
We are going to see that it is possible to look at an example of how this is going
to work. If we are working with one of the boards that come with Arduino, the
Arduino UNO, there are going to be six pins for input that helps with the analog
signals that go from A0 to A5 and it is able to measure out the voltages with 4.8
millivolts and that means it is going to be accurate when measuring out a lot of
the applications.
How Can Our Sensors Give Us the Analog Signals?
The next thing that we need to figure out here is how the sensors are going to
help us to generate some of these signals that are considered to be analog. We
can work with the sensors of a thermometer or temperature for the example that
we are going to use here. The sensor that we are using here is going to have a
transistor that is very sensitive because it is made out of silicon. And we know
right from the beginning that silicon is going to be really affected by the
temperature that we have.

There are a few steps that we are able to go through in order to help us see how
this kind of sensor is going to work, and how we are able to set it up to provide
us with the analog signals. These steps are going to include:

1. We need to bring along 2 AAA batteries and put them together inside
of the holder for the batteries. This is going to give us 3 volts.
2. We can then go through and connect the red wire with that of the
holder of the battery to the temperature of the Vin’s leg.
3. Then you can take the black wire and connect it to the back of your
holder of the battery. Then connect the other part to the temperature
sensor that is on the GND leg.
4. Put the multimeter to the voltage mode.
5. Connect the leg of the GND to the black probe and then connect the
red probe to the Vin leg as well.
6. Note that there should be a reading on the voltage to our multimeter.
It should be at 0.76 volts if you have it all set up the right way.
7. Now you can put your hand onto the sensor. This is something that
should be enough to raise up the temperature that you are working
with. Check to see what the reading on the multimeter is. the reading
is going to rise and go higher because you raised the temperature.

As with any of the sensor work that is in the same manner of the temperature
sensor, it is going to behave based on what the factors of the environment are
doing and the changes that happen with the internal resistor, so it is going to
doing and the changes that happen with the internal resistor, so it is going to
change the output voltage, and you will be able to measure it out on the analog
sensor.
Looking at an Example with a Control Light
In addition to the thermometer that we are going with above, let’s take a look
another thing that we are going to be able to do when it is time to handle this
kind of project. We are going to take a look at how to work with a control light
with the help of the right amount using a potentiometer and the right wiring to
make it happen.

//create new file from the Arduino IDE and write the following code:

const int sensorPin = A0;

const in LedPin = 13
int sensorValue;
void setup ()
{
PinMOde (LedPin, OUTPUT);
}
void loop()
{
sensorValue = analogRead(sensorPin);
digitalWrite(LedPin, HIGH);
delay(sensorValue);
digitalWrite(LedPin, LOW);
delay(sensorValue);
}

As we can see, this is a fairly simple code that we are able to work with. We are
also able to add in the analogRead(pin number) if we would like to help us read
out the voltage as an analog signal. The controller is able to measure out the
voltages from 4.8 millivolts to 5 volts. It is also going to convert these values
over to digital values going from 0 to 1024. His conversion is going to be known
as the analog to digital converting.

Then we need to look at the statement in the code above that is sensorValue =
analogRead(sensorPin); In this statement, our controller is going to store the
value of the sensor reading in the variable of the sensor value and then the
controller is going to be able to turn the LED light on and off for a period of time
equal to this variable. In this example we were able to work with a variable
equal to this variable. In this example we were able to work with a variable
resistor so that we were able to change up the value of the resistance as well to
suit our needs.

And that is all there is to the process. We have now been able to go through and
create one of our own codes, and you can see how easy it is to do some of the
coding that you want with the Arduino board in no time. There are so many
other things that we are able to do when it comes to using he Arduino board, and
we just need to take the time to learn how to use codes like the one above to
make it work.
Chapter 11: Computer Interfacing with Arduino

There are any times that you will want to take the Arduino board and connect it
up to your computer to get some more of the work you need done. Computer
interfacing with Arduino is common, but there are a few steps that you need to
take to make it all happen. The method that you are going to choose to use when
it is time to interface the board with your computer is really going to depend on
the kinds of cables that you have available to you in the beginning.

Remember here that each of the Arduino boards that you work with can simply
connect back to a computer with the help of a USB port. Connecting the Arduino
over to the computer of your choice will also depend on the programming
language that we want to work with and the add-ons that you need to incorporate
to let the Arduino interface smoothly with your computer. This is what we are
going to explore a bit more in this guidebook.
The FTDI Chips
One thing to take a look at here is the FTDI chips. All of the boards of Arduino
are going to have the capabilities of sending and receiving data to and from the
computer with the help of the USB port, with the exception of the Lilypad and
computer with the help of the USB port, with the exception of the Lilypad and
Mini boards. But you are able to still connect these boards to the computer with
the help of the FTDI interface. This is basically going to be a small chip that is
going to be used to help us exchange data between the computer and your own
microcontroller.

In the last example that we did in the previous chapter, we were able to use
Arduino in order to read some of our sensor values like light and temperature,
and you are able to show all of these on the LED of that board. But in this
chapter, we are going to take a moment to work with serial interfacing to send
the sensor values to the computer so that we are able to get the calculations that
we need.

Example of Temperature Sensors with Serial Interface

It’s time to work on another example and see how we are able to use this to help
us get things done. We need to have a breadboard, the Arduino UNO board, a
temperature sensor, and a B USB cable. The code that we are going to need to
make all of this happen includes:

const int sensorPin = A0;

int reading;
float voltage;
float temperature;
void setup()
( Serial.begin(9600);}
Void loop ()
}
Reading = analogRead(sensorPin);
Voltage = reading * 5.0/1024;
Serial.print )voltage);
Serial.printIn(“volts”);
temperatureC = (voltage – 0.5) * 100;
Serial.printIn(“Temperature is”);
Serial.print(temperatureC);
Serian.printIn(“degrees C”)’
Delay(1000);
}

After we have been able to verify and then upload the code that we want to work
with, we can click on the Serial Monitor that comes up. You should see that
with, we can click on the Serial Monitor that comes up. You should see that
there is a menu that is going to show us the sensor readings of the temperature.
Now we want to use any heat source that we can find in order to raise up the
temperature of the device. Keep in mind that with this device, we are able to
handle up to 150 Celsius. You may also see the (-) symbol show up. This does
not mean that we are working with negative numbers on this one, but it is simply
a programming error that is temporary.

We can also go through and look at more of the parts to see how this is all going
to come together to help us write out this code. To start with, we can look at the
Serial.begin(9600);. This is the statement that we need to write out in order to
help us start up the communication of the computer and the Arduino through the
USB port, so we are able to send and receive data back and forth with the
computer.

There are going to be two variables that we are going to see in our code,
including the voltage and the TemperatureC, and they have been defined using a
float rather than an integer because the temperature sensor is going t be really
accurate, and the result is going to be in a floating points number, rather than an
integer.

Then we are able to move onto the part of the code that is for reading =
analogRead(sensorPin);. This is the instruction that we need to use to help us
record the analog input into the right pin of the process. As we mentioned a bit
before, our controller is going to be able to convert the analog signal into a
digital value from zero to 1024, and then we are able to use the instruction of
voltage = reading * 5/1024.

After we have gone through the conversion of our digital values over to voltage,
we are going to use the command of Serial.pinrt(voltage); to help us send this
value over to the computer, effectively getting it to show up on the IDE for
Arduino. The Serial.print(“voltage”); part of the code is going to be the
instructions to the system that we want it to print the word “voltage” after we get
that value.

Then it is on to the TemperatureC = (voltage – 0.5) * 100; This is going to be the

instructions that we need in order to convert some of the voltage values to the
temperature degrees, and we are using Celsius here and then we can print out the
value then the word Temperature and degree C. and then we get to the last part
of the code, the delay(1000), that is there to make the controller wait one second
before it sends the voltage and the temperature value to the computer again and
before it sends the voltage and the temperature value to the computer again and
then we can seethe results there.
Chapter 12: The API Functions

Now we need to spend some time moving over to another topic and seeing how
we can make this work for our needs as well. In this chapter we are going to
spend a bit more time going into details that are provided by the API of the
Arduino. The API of Arduino is going to be rich and full of different things that
are provided to the Arduino programmer, and will help them to have more
options on the kind of programming that they want to work on.

The team that works with and develops this technology has done a great job at
providing a full-featured API that is going to give the programmer a large
variety of different things that they are able to do when they tinker on the
Arduino overall. We are going to divide these up and look at them in more
depth, hopefully to help you learn more about how these functions work and
what you are able to do with them for your own needs.
The Digital Input and Output
There are going to be a few different functions that we are able to define with the
Arduino API to help us to work with the digital pins that are there. this section is
going to take a look at some of these functions, including he three most popular
options that are there. A good place to start though is the following code:

pinMode(pin, INPUT – OUTPUT – or INPUT_PULLUP)

This is going to be useful because it allows us to specify a given pin and then
designate whether that pin is going to act as an input or if it is going to be an
output instead. Newer models of this Arduino are going to be able to have heir
pins enabled through the pullup resistors, which is why we added this mode to it
as well.

Then we are able to look at some of the Analog input and output that we are able
to work with. On top of the usefulness of our digital pins, we are also going to be
able to work with our analog pins. These functions are going to be helpful
because they will help us to read the voltage from a given pin, which is going to
fall between 0 and 5 volts. The upper range that we are dealing with will be
closer to 1023 and then the lower is going to be closer to 0.

The code that we need to use to make this happen is analogRead(pin). This will
read to us the voltage that is in any given pin that we choose. And this will come
back to us as an integer from 0 to 1023. Or we can work with the
analogReference(type) which is going to be able to configure the voltage to be
used as our reference point. The way that we use this is going to depend on the
type of Arduino that we work with.

For the most part, we will be able to go through and specify “type” as the default
or the internal. There will be a few cases where we may find that we will want to
specify a different reference voltage though to help us get this done.

Then it is time to move on to some of the advanced options of the input and
output that we are able to use with Arduino. These are not going to really fall
under either of the two categories that we have done so far because they are not
really digital or analog. But they are going to be more advanced categories of
input and output that will allow you to do more in general with the board that
you have.

To start, we have tone(pint, frequency, OPTIONAL duration). This one is going

to make it so that we are able to specify the given frequency and then we can
generate out a square wave of that frequency onto the pin that we are using.
Then we can work with noTone(pin) that will help us stop the tone that is being
generated out of the tone function when we would like.
It is also possible to add in a type of pulse to the mix as well. We could use the
code of pulseIn(pin, value) that is going to allow us to read the pulse of any
given pin that is there. If the pin is fluctuating between high and low at this time,
then it is going to return the time in microseconds between the high and the low.
Because the pulses may not be completely even at this time, you can actually go
through and specify whether you want it to read out the HIGH pulse, or the
LOW pulse based on what works the best for what you are doing.

Now we are able to work with pulseInLong(pn, value). This is similar to what
we talked about with the last function, but instead of giving you an integer
number of microseconds, it is going to return a long number of microseconds,
which essentially is going to offer a much larger time dimension for which you
are able to receive data.

The shiftIn(dataPin, clockPn, bitOrder) option is going to be able to send over a

byte’s worth of data to a given pin, bit by bit. The data pin is going to be the pin
where you will be sending each bit, the clock pin is going to be the pin that will
designate that the dataPin has read through the data, and then the bitOrder can
either be the most significant or the least significant based on how you would
like to sort through all of this.
Time
Another thing that we can focus on for a moment is the function of time when
we are working with our Arduino board. These functions are going to be
intended to help you in working with some of the things that are time-sensitive,
such as the scope of Arduino. The first code that we can work with here is the
delay(value). We have seen this in some of our examples so far, but it is going to
allow us to pause the sketch for a certain amount of time of our choosing. We
can add in the integer value and keep in mind that it is going to be in
milliseconds here.
Then we have the delyaMicroseconds(value). This is going to be the one that is
functionally the same as that delay() function that we just saw. But it is going to
work in microseconds rather than in milliseconds. So it often depends on how
long you would like that delay to be.
Math
Even though it may not seem like the case, you will find that sometimes the
programming that you want to do is going to involve a lot of math. The math
functions in Arduino API are going to be similar in many ways to those math
functions that are defined by the C math library, but they are going to make it
functions that are defined by the C math library, but they are going to make it
easier because you can use them without having to import any additional math
libraries. Even if you don’t end up using a lot of math in the programs that you
are writing, you will still be able to benefit from knowing that these exist
because there may be a surprise time when math sneaks its way in.

With this in mind, we need to take a look at some of the different codes that we
are able to work with. First, we can work with abs(value). This is going to be the
function that can return the absolute value of a given number, or the distance
between zero and a given number on our number line.

Then we can work with constrain(variant, lowerBound,

upperBound). This one is going to allow us a way to create a function
such that the number will also be within our upper or our lower
bound.
Next on the list is map(number, fromMin, fromMax, toMin, toMax).
This one is going to help us to map out a number from one range to
another range.
Max(number1, number2): This one is going to return to us the
highest number of number1 or number2 when we need it.
Min(number1, number2): This one is going to be the opposite of
what we were seeing before. It is going to help us return the lowest of
the two numbers above.
Pow(base, exponent): This is going to allow us to take a given
number and then can raise it to an exponent. C, which does not come
with an exponential operator, will use this function quite a bit in
Arduino.
Sq(number): This is going to be a good one to use because it returns
to us the square of a given number).
Sqrt(number): This one is similar to the one before, but it is going to
help us out because it will calculate out the square root of a given
number.
Cos(angle): This one is going to help us out by computing the cosine
of a given angle, with the angle to be specified in radians.
Sin(angle): This is going to go through and help us to compute the
sin of a given angle. The angle will be specified out in the code with
the help of radians.
Tan(angle): This is going to be used to help compute the tangent of a
given angle. Again, this one is going to be done in radians as well.

There are many times when you will need to go through and work on some of
There are many times when you will need to go through and work on some of
your codes in this language and you will need to work with some math. Often,
they happen in programs that you would not think would need this. Knowing
some of the codes that we have above will make it easier for us to use these
functions when they come up.
The Characters
Next, we are able to move on to the characters. While these are going to be
relatively rare when we are working with the Arduino language it is still
important that you have a set of functions that are going to be primed for you to
use whenever you are focusing on the sets of characters that you would like to
use. Some of the examples of characters that you are able to work with will
include;

1. isAlpha(character): His one is going to return whether or not the

character we are using is alphabetical.
2. islphaNumeric: This one is going to give us a character returned even
if the character is numeric or alphabetic.
3. isAscii(): This one is going to let us know whether or not the
character is an ASCII character.
4. isControl: This one is going to let us know whether or not the
character is considered a control character.
5. isDigit(): This is going to return whether or not the character is a
number.
6. isGraph(): This is going to return whether or not the character is
something that has visual data. A space, for example, is not going to
have any of this visual data.
7. isHexidecimalDigit(): This one is going to let us know whether we
are working with a hexadecimal or not.
8. isLowerCase(): This one is going to let us know whether the
character is lowercase or not.
9. isPrintable(): This is going to let us know whether or not the
character is one that we are able to print off on a console.
10. isPunct(): This one is going to let us know whether or
not the character that we are getting back is a punctuation mark.
11. isSpace(): This one is going to let us know whether
the character that we are getting back is a space or not.
12. isUpperCase(): This one is going to let us know
whether the character that we are getting returned is an upper case
 letter.
13. isWhiteSpace(): This one is going to let us know
whether the returned character that we are working with is going to
be a whitespace character, like a line break, space, or a tab.

The Random Numbers

While there are only really two of these that we need to spend our time on, we
still need to focus on them a bit. These are the functions that we are going to use
in order to create some random numbers in the program that we are writing.
Note that the computer can never really be spontaneous and random. This is
because all of the parts that come with it are going to be based on the inputs, and
nothing can be done without some of these inputs on the computer to start with.
This is why when we are working with the random function here, it has to be
seeded.

The first one that we are going to focus on is the randomSeed(number) function.
This one is going to start up the random number generator that we want to work
with. You will need to feed a number through it, and then it is going to start at a
random point of its choice within the sequence of the pseudo-random number
generator’s numerical sequence.

Then we are also able to work with the random(OPTIONAL minimum,

maximum). This is going to be the one that will work to bound together the
random number generation. The maximum value is going to be the highest
random number that you are going to allow, and then the minimum input is
going to be the opposite and will be the lowest value that you are going to allow.
If you do not specify this minimum, then it will assume that 0 is your minimum.
The Bitwise Functions
Next on the list of functions that we need to work with are the Bitwise functions.
These are the functions that will allow you to work with the bits and the bytes of
your code. These are the smallest pieces of data that the computer is able to work
with. You can, in theory, work with smaller values when we are talking about
the overall power that is required for computing. But the bits and bytes are going
to be the smallest practical values that you will be working with while
programming in Arduino. Some of the bitwise functions that you are able to
work with will include:
 1. bit(bitNum): This one is going to provide us with the value of a given
bit.
2. bitClear(variable, bit): This one is going to be how we set the given
bit of a specified numerical variable to 0.
3. bitRead(variable, bit): This is going to give back the bit of a specified
numeric variable.
4. bitSet(variable, bit): This is going to set a given variable’s bit as the
position denoted by bit to 1.
5. bitWrite9(variable, bit, 0 or 1): This one will set the bit at the given
position inside of the variable to either be at 0 or 1, depending on
what you set in the code.
6. highByte(value): This one is going o return to us the highest byte of a
given value that we have.
7. lowByte(value): This one is going to be the opposite of before and it
is going to return the lowest byte of the value that you choose to look
at.

As we can see, there are a lot of functions that we are able to focus on when it
comes to working with the Arduino API. Learning what all of these are able to
do for us, and exploring them in more detail can make a big difference in what
you are able to do with some of the codes that you decide to work on as well.
Make sure to explore some of these a bit more and experiment to see how they
are going to work and how we are able to use them for some of our own codes.
Chapter 13: Using the Stream Class
This is a topic that is going to be so important to what we are trying to do with
some of our work that it really did deserve its own chapter to help us get the
work done. While this one is still going to work with the API of Arduino that we
talked about before it is going to be pretty broad and will talk about a lot of
different parts, so we are going to break off here and work with the stream class,
which also allows us to work with strings along the way.

The stream class is going to be a fairly simple concept even though it is really
important to work with. The stream class on its own is going to be based on
using reading information from a certain source, and then having this as how you
make up your own sketch. Because the stream is all about reading the data, it is
also important that we talk about working with a mouse and keyboard with the
Arduino board in this chapter, even though we may think that these are not going
to be related directly to the stream class that we are working with.

When you decide to work with the data, especially when you are readying the
data, you will find that there are times when we need to work with sets of
characters that are longer, like a sentence. The idea of strings is going to give
you the chance to do this on our board. Strings are going to basically just be sets
of character values that will be linked together like with an array. This means
that they are going to be contiguous in the memory, and the computer is going to
see them as one large and interconnected unit. Working with the strings means
that we need to learn how to manipulate these units as well as our abilities will
allow.

On its own, it is going to be pretty simple. Thought to work with. Strings are just
going to be what we know as character arrays. That means that we are still
working with some of the C-style strings, which are going to be strings that have
abstraction at a very low level. For example, in a lot of the newer programming
languages, the strings are not going to be revealed in their character as a
character array. Instead of doing this, they are going to be treated as an abstract
object instead. Even if they are considered a character array, they will be treated
in this manner.

A string is going to be composed of the n + 1 characters, where n is going to be

the number of letters that is in the string in general. So, for example, the size of a
string for the word “hello” would end up being the six characters. The reason for
this is because the string is going to end in a null terminating character, which is
this is because the string is going to end in a null terminating character, which is
going to indicate to us that the end of the array has been reached and that it can
be ended.

You are able to go through and define a string in the same manner that you
would an array. You are able to also make them bigger than the string that you
plan to have them contain. When you go through the process of defining an array
you may give it a value right of the bat, but you can also just define the size and
expand them out at a later time. this also makes strings, more dynamic and can
allow us to change them up later on when we rewrite some of the data that is
inside of that string.

This information is going to be useful to a programmer who is just getting

started because these strings are going to be fundamental and important to any of
the programs that you use that handle information, especially those that are
going to handle the input and the output of the file. We have already spent some
time looking at this, now, but we also need to go ahead and learn how we are
able to define our string. The code that we are able to use for this one will be
below:

char myString[6] = “hello”;

You can then spend some time referring to this entire string at a later point with
the name of the character. Most of the data that is worked with by the board is
going to be worked with in terms of how many bytes it is, and most of the actual
textual data is going to be worked with in terms of C strings because it is easy to
parse these characters when you would like.

It is important that we go over all of these parts so that we learn and develop the
right ideas that we need when it is time to treat the strings in this kind of
programming and we see what we are able to do with some of these parts as
well. Let’s dive a bit more into this to see how it will work.
The Serial
While you are not necessarily able to implement the stream class in itself, you
are able to go through and implement some of the derivatives of it, and this is
where we are going to find a lot of the utility that we need. The serial class that
we are going with here is going to be an extension of what we are able to do with
the stream class, and it is going to help us to communicate with some of the
other devices that we want, such as the computer.

The serial is going to be enacted through both the port on the Arduino for the
The serial is going to be enacted through both the port on the Arduino for the
Serial, as well as on the link for the USB on the computer. We are going to then
look at some of the functions that are available with the Serial class, making it
easier for you to use this kind of thing and get the most out of this resource along
the way as well:

1. Serial.begin(rate): you are already familiar with how this one is going
to work. It is a good one to use to help us start out the serial
transmission of our data. You are also able to specify the specific rate
of the data transmission that you are getting and see it in bits per
second.
2. Serial.end): This function is going to allow us to end the
communication through this. You can then go through and restart the
communication by working with the Serial.begin() function that we
did before. While the communication is disabled for whatever
purpose, you are able to use the serial pins for generalized entry and
exit of the data.
3. Serial.find(string): This is the one that is going to search for the given
string within the data that is provided by the Serial. If the string is
found, then the method is going to return true. If the string is not
found, then the method is going to return the output of false to us.
4. Serial.findUntil(string, OPTIONAL endString): This one is going to
take some time to look for a specific string within a serial buffer,
until either the string is found or the specified terminating string is
found. If the target string is found, then the method is going to return
true to us. If the terminating string is found or if the method times
out, then you are going to get a return of false.
5. Serial.flush(): This one is going to all you time to halt a process until
all of the data that is being sent to the serial has been sent.
6. Serial.parseFloat(): This function is going to work for us by returning
the first floating point number to be provided with the serial stream.
It is often going to be brought to an end with any character that is not
seen as a floating point.
7. Serial.parseInt(): This one is going to be able to work by returning
the first integer number to be provided by the serial stream. It is
going to be brought to an end by the first character that you are
working with that isn’t a digit.
8. Serial.peek(): This one is going to return the very next character that
should be imported by the serial buffer. However it is not going to
 remove any of the character from the bugger. This makes it a bit
different than he Serial.read() method that we will talk about soon.
This means that you are just going to be able to see which of the
characters are coming next.
9. Serial.pint(value, OPTIONAL format): You are able to specify the
format as well as an option. Otherwise, the integers are going to print
as decimals by default. The floats are going to print with two decimal
places by default, and so on. You are able to send strings or
characters as is to the print statement, and it is going to do the
printing that you need without any issues.
10. Serial.pintln(value, OPTIONAL format): This one is
going to allow you to prin out some of the values, just like we would
expect with some of the other print methods out there.
11. Serial.read(): This one is going to be able to read the
data that is showing up through your serial port. This is going to be
added to some of the incoming stream of serial data and it is known
as the serial buffer. When you read from this buffer, the information
will then be destroyed, so we need to make sure that we are saving
the data to a variable if we wish to reuse it at one point or another.
12. Serial.readBytes: This one is going to help us read in
the characters from the serial port to the buffer. You are able to
determine the number of bytes that you would like to see read. Your
buffer has to be an array that is a byte or a char.
13. Serial.readBytesUntil: This one is going to work on
reading the characters from the serial port, either until the given
number of bytes has been read through on there, or until the chosen
terminating character is read through as well. In either case, the
method will then be able to terminate.
14. Serial.write(): This one is going to write out the data
to the serial port. But this method is only going to send over data that
is binary to the serial port. If you need to send over other kinds of
data, like ASCII, you will need to work with the print method
instead.
15. Serial.serialEvent(): The last method that we are
going to take some time looking at is this one. Whenever the data you
need comes to be available for use with your port of he serial, then
this is going to be the function that is called. You can then use this
function to help us read the data from the serial port.

As we can see here, we have spent a good deal of time talking about a lot of
As we can see here, we have spent a good deal of time talking about a lot of
different topics, especially the functions that we are able to use when we are
working with the serial class and how it is going to pertain to some of the
programming that happens with the Arduino API. This can help us to get so
much done with some of the coding that we need, and can be an important class
that will help us to get more done with our API.
Chapter 14: Working with User-Defined Functions

Another thing that we need to take a look at before we end this guidebook is the
idea of the user defined function. One of the methods that you are able to keep
the code that you are writing, in Arduino and in other languages, clean and
organized and modular or reusable, is to make sure that you work with functions
inside of that code. In addition, these functions are able to make some of the
code smaller because parts of the code, and small sections of it, can be reusable.
Functions are going to be like tools that were created in order to serve the
particular function that you would like, just like the name is going to suggest.

While we have already gone through and encountered some examples of these
particular functions as we go through this guidebook, we now need to go through
some of the details that come with them and really understand some of the parts
that go with them. This is going to help us to explain some of the features that
we may have glossed over in the first place, so that we really know what these
functions are like.

The first thing that we are able to do here is to look at the declaration of the
function that we want to work with. A good example of how to do this is going
to be below:
to be below:

float employeeEarnings (float hoursWorked, float payrate) {

float results: // this will be the value that we are going to return when this
function has been called up. We want to make sure that it is going to match the
type of data that we are using before the name of the function

results = hoursWorked * payrate

Return results // return tells the function that it needs to send a value back once
to where it was originally called.
}

Take some time to look over that code and see what it is able to offer in terms of
what you are able to do with it, and even what you are able to understand out of
the code based on what we have already been able to work with. You can even
get some practice in order to get better at this by typing the code out a few times
and gaining a feel for it.

This function is going to take on two arguments in order to be successful. It is

going to be with the hoursWorked and the payRate in order to handle some of
the work that we are doing, and both of these are going to be floats. It does take
us some time to work on simple math on these and then it is going to return a
float as the value.

The return that we are working on here means that we want to end or terminate
the function and then send back the value that was placed with us, after the word
return, which is usually going to be a variable, as the results of the calculations
that we did. All of this is going to be done to help us understand how these
functions work and how we are able to do some stuff with them.

With this in mind, we then need to go through and call up this function. This will
allow us to see what the earnings of the employee’s are, and can make it easier
to see what we are going to get out of this process as well when we work with
some of the functions. The code that we are going to need to work with to make
this happen will include:

void loop () {
floathoursWorked = 37.5;
float payRate = 18.50;
float result = employeeEarnings (hoursWorked, payRate)
float result = employeeEarnings (hoursWorked, payRate)
// results will be 693.75

This is a pretty straightforward cod that we are able to work with, but it is
definitely going to show us what we are able to do here, and why all of the parts
are going to be important along the way. it is also a simple way to get some ideas
on how the function is going to work overall.

The first thing that we are going to find here is that the function we want to
declare has to be declared independent of and outside of the other functions. This
means that we need to be able to write the code for the function that we want to
create, doing so either inside of the loop function or the setup function. You can
also work with some of the other user defined functions that are there.

We can also go with this and look at another example that will make it easier to
see how this is supposed to work. We are going to look at a sample sketch here
that is going to be used in many cases to help us smooth out some of our
readings of the sensors:

int sensorSmoothin (analogPin) {

in sensorValue = 0;
for (int index = 0; index < 5, index ++)
digitalWrite(LED_BUILTIN, HIGH); //Turn on the LED for smoothing.
sensorValue= sensorValue + analogRead (analogPin)
delay(100) // 100 millisecond delay between the samples
}
digitalWrite(LED_BUILTIN, LOW); //turn off the LED
sensorValue = sensorValue / 5 //average the values over five samples that we are
using.
return sensorValue;
}

As you go through some of this, you are going to find that this is going to show
up a lot of the functions that we were talking about earlier on. This is going to
make it so much easier for us to feel comfortable with some of the work that we
are trying to do along the way. The more time that you spend working on some
of the coding that we want to do along the way, the easier it is to work with the
code because we are comfortable and can recognize things along the way.

This is a good function to work with because it is going to be used to help us to

smooth out the input of the data of many sensors, especially if you find that they
are prone to inputs that are a bit jittery in the process. This is going to work well
are prone to inputs that are a bit jittery in the process. This is going to work well
because it is able to average out the sample to give us a more consistent flow of
data. We are able to see that the code we just did above is going to be similar to
some of the sample that we did in the beginning. Let’s take along look at it to see
what it did there:

With all of this, we are going to be able to work on initializing our sensorValue
variable so that it is going to be able to call up the sensorSmoothing() function
that we need. This is all going to happen on the analog pin of 0, and can help us
out here because it is going to make sure that we are able to average out the
results that we have over not just one sample, but over five samples that we are
able to use.

Of course, we have to remember that the functions we are working with are not
going to always be as smooth and easy to work with as this example. The
functions are not always going to need to have parameters or return variables in
order to work either. Sometimes the functions can be set up to return no value,
and then they can also have no parameters in the process either. All that they are
going to do when you bring them up is to execute the few lines of code that you
want, and then you can terminate it all, bringing the compiler back to the place
in the code where you called them from.

As you can see, these user defined functions are not going to be as difficult as
they may seem in the beginning. With a bit of practice, and even trying out a few
of the functions that we were able to work with in this chapter, and doing some
of your own, you will find that you are able to make these user defined functions
work the way that you would like and they will help your Arduino technology
complete the project.
Conclusion

Thank you for making it through to the end of Arduino Programming , let’s hope
it was informative and able to provide you with all of the tools you need to
achieve your goals whatever they may be.

The next step is to purchase the kind of Arduino board that you would like to
work with and then go on from there. In the beginning of this guidebook we
spent some time looking at what the Arduino board is all about and some of the
different options that you are able to use in order to make it do the work that you
would like. And picking out the board that is going to help you with some of the
projects that you want to complete is going to be an important first step to focus
on.

From there, it is time to go through the various steps that we spent our time on in
this guidebook so that you can learn a bit about this language and what it is able
to do for you. There are many beginners who are worried about learning any
kind of coding at all, much less the Arduino language. But you will quickly find
that this is a simple language that you are able to work with, one that will help
you to see the best results in no time, and is designed for the student, or someone
with no engineering or technical experience, to gain some experience on coding
in the first place.

There are a lot of different parts that are going to come with this language, and
being able to explore it some more, and learn from what is there, is going to
make a big difference in the response that we are able to get, and how good we
feel about some of our own coding prowess along the way. Don’t be worried our
scared about the topics that we are going to explore in this guidebook. You will
find that they are easy and before long, you will be able to hook up the Arduino
machine and get it to work on any project that you want.

And that is just one of the things that we explored when it came to working in
this guidebook. We took a look at what the Arduino technology is all about and
how it was designed to help the beginner to grasp coding and get their foot in the
door. We took a look at some of the benefits of working with this kind of system
and why it is the best way to learn a language. We even spent some time
exploring the different types of boards that are available, how they work, and
how to hook this up to the computer so that you can download the code that you
need, and the software, and get it up and running.

In addition to some of those great benefits and the basics of the Arduino, we
took it a bit further and looked at some of the things that you are able to do with
this system when it comes to coding. We looked at many different parts such as
how to turn it into a machine, how to work with the stream class and the Arduino
API, and even how to create some of your own user defined functions along the
way. all of this came together to help you learn some of the basics of your first
coding language, and make it easier for you to get into this world in no time.

There are so many things that you are able to love when it comes to using the
Arduino technology to help you out with some of the coding that you would like
to accomplish. And getting started on it is easier than you may think. When you
are ready to learn how to code, but you want a nice and simple method to use in
order to do this, make sure to check out this guidebook to help you get started.

Finally, if you found this book useful in any way, a review on Amazon is always
appreciated!