Forum Donate

Learn to code — free 3,000-hour curriculum

OCTOBER 5, 2023 / #ARDUINO

The Arduino Handbook

– Learn
Microcontrollers for
Embedded Systems
Ihechikara Vincent Abba

Arduino is an open-source platform that

combines hardware and software in
 Forum
designing and building electronic projects.Donate
Learn to code — free 3,000-hour curriculum

Arduino can be applied in a variety of projects like:

Home automation.

Internet of Things (IoT).

Audio and music.

Automated and remote controlled systems.

Automation in agriculture.

Electronic prototyping.

Wearable devices, and so much more.

The hardware part of Arduino comprises Arduino

boards, input and output devices (including digital and
analog pins, and sensors and actuators), shields,
breadboards, jumper wires, and so on. These
components can be combined together to create
dynamic and interactive projects.

The software is made up of the development tools

used to write, debug, compile, and upload code to
Arduino boards. Most 0f the software tools can be
found in the Arduino IDE (Integrated Development
Environment).
This handbook will help you understandForum
how Arduino
Donate
works. You'll learn
Learn about
to code the
— free Arduino
3,000-hour boards, the
curriculum

components that make up a board, and how to

connect devices to them.

We'll talk about input and output peripherals which

help the microcontroller (the brain of the Arduino
board) process information coming from the physical
environment, and send output based on programmed
logic.

You'll learn about the Arduino IDE, how to code using

the Arduino programming language, and how to use
sensors, actuators, and other components to build
projects as you learn.

You'll also learn about serial communication, which

helps Arduino boards communicate with other
computers.

This handbook is written for makers (students, artists,

hobbyists, programmers) who are beginners.

Prerequisites
Although it would be helpful, you don't need prior
programming knowledge to use this handbook. You
 Forumfrom Donate
will learn the basics of Arduino programming
scratch. This cantoalso
Learn code serve as your introduction
— free 3,000-hour curriculum to
programming.

To make it beginner friendly, we won't talk about some

aspects of electronics like current and voltage,
resistance, circuits (series and parallel), and most basic
electronic/electrical laws and requirements for
students in STEM (Science, Technology, Engineering,
Mathematics) fields.

Whether you have knowledge of these concepts or

not, you can learn about Arduino using this handbook.

If you know how to use a breadboard and a resistor,

then that's all the knowledge on electronics you'll
need to follow along.

In summary, this handbook is for everyone. You don't

need an engineering degree to become an Arduino
maker!

Table of Contents:
Prerequisites

Chapter 1: Getting Started with Arduino

Chapter 2: Basics of Arduino Programming

 Chapter 3: How to use Digital Pins inForum
Arduino Donate

ChapterLearn to code — free 3,000-hour curriculum

4: How to use Analog Pins in Arduino

Chapter 5: How to use Sensors and Actuators

in Arduino

Chapter 6: How to use the Serial Monitor in

Arduino

Chapter 7: How to use Displays in Arduino

Chapter 1: Getting
Started with
Arduino
The Arduino development and design process
comprises both hardware and software. So knowing
how they work together is important for building the
right foundation for your journey.

In this chapter, you’ll learn about the different

components that make up the Arduino Uno board.
You'll also learn how to install the Arduino IDE and set
up your development environment.
At the time of writing, a new Uno board Forum
was released
Donate
— the Arduino
LearnUno R4.
to code This3,000-hour
— free handbook will make use of
curriculum

the Uno R3 board, but you can follow along with either
of them. The R4 board comes in two variants —
Arduino Uno R4 WiFi and Arduino Uno R4 Minima —
with cool additional features that you can read about
here.

Components of the
Arduino Uno R3 Board
There are many types of Arduino boards like Arduino
Nano, Arduino Uno, Arduino Mega, Arduino Leonardo,
and so on.

These boards have some common features — they all

have digital and output pins, they’re programmable,
and they all have a microcontroller.

But there are also some differences. Each board varies

in size and shape, and usually has more or fewer
components when compared to other boards.

The common boards you’ll come across as a beginner

are the Nano, Uno, and Mega boards. The most
commonly used is the Uno board, which we’ll use for
this handbook.
 Forum Donate
Here are some of the components you'll find on the
Learn to code — free 3,000-hour curriculum
Uno R3 board:

A power port.

USB connector.

Microcontroller (ATmega328).

Analog pins.

Digital pins.

Reset button.

TX and RX indicators.
Arduino Uno R3 board (https://store.arduino.cc/products/arduino-
Forum Donate
uno-rev3)
Learn to code — free 3,000-hour curriculum

You’ll make use of most of the components listed

above as you progress through this handbook.

How to Install and Set Up

the Arduino IDE
You can use the Arduino IDE to program Arduino
boards. That is, you write the code in the IDE, then
upload it to the board.

In this section, you’ll learn how to set up the IDE, and

create your first Arduino program (also called an
Arduino sketch).

You can download the latest version of the Arduino

IDE on the Arduino software download page. You can
download the IDE for different operating systems —
Windows, MacOS, and Linux.

The installation process is similar for the operating

systems listed above. Here’s how to install it on a
Windows machine:
Step #1 – Download the Arduino Forum Donate

IDE Learn to code — free 3,000-hour curriculum

The first step is to download the IDE from the Arduino

software download page. You should see a section of
the page similar to the image below:

On the right side of the image above are different

download options for specific operating systems.
Make sure you download the option that suits your
operating system.

I'll use the ZIP file option for Windows. If you decide
to download an installer instead, then you can follow
the installation steps after clicking the installation file.
Step #2 – Unzip the Downloaded Forum Donate

File Learn to code — free 3,000-hour curriculum

Go on and unzip the downloaded file. This gives you

access to all the resources needed to run the Arduino
IDE.

After unzipping the file, you should see files like these:

Image showing the files you should see

To launch the Arduino IDE, click on the file that says

“Arduino IDE”.

Step #3 – Overview of the

Arduino IDE
 Forum
Now that you’ve downloaded and installed the Donate
Arduino IDE, thetonext
Learn code —part is to get familiar
free 3,000-hour curriculum with the

development environment. In the next section, you’ll

learn how to upload code to an Arduino Uno board
using the IDE.

Before that, let’s have a look at some options you’ll

find in the Arduino IDE. At the top left corner of the
IDE are five options — File, Edit, Sketch, Tools, Help:

Screenshot showing these options (File, Edit, Sketch, Tools, Help)

The “File” option lets you do different things like

creating a new sketch (we’ll talk about sketches in the
next section), opening an existing sketch, Arduino
 Forum
practice examples for beginners, keyboard shortcuts,
Donate
save options, and
Learn so on.
to code — free 3,000-hour curriculum

The “Edit” option gives you access to text formatting

options like copy, paste, cut, comment/uncomment
code, font size options, text search options, and so on.

You can use the “Sketch” option to verify and compile

code, upload code to Arduino boards, optimize code,
and add libraries.

You can use the “Tools” option to manage libraries,

format code, access the serial monitor and plotter,
select an Arduino board and port to upload code to,
choose a processor, and so on.

The “Help” option provides resources for

troubleshooting, information on IDE updates, guides
on “getting started”, and so on.

Next, let’s look at some other parts and functionalities

in the IDE that you’ll find useful. The image below,
from the Arduino documentation, highlights them
perfectly:
 Forum Donate
Learn to code — free 3,000-hour curriculum

https://docs.arduino.cc/software/ide-v2/tutorials/getting-started-
ide-v2

Verify/Upload: You can use these options to

compile and upload code to Arduino boards.
You’ll get error messages if the code doesn't
compile as expected.

Select Board & Port: You can use this option to

select a port and port number to upload your
code too. The current version of the Arduino
IDE automatically detects both boards and
ports.

Sketchbook: This gives you access to all the

sketches created in your computer. You can
also access sketches saved on Arduino Cloud
(mostly used for creating IoT projects).
 Forumwith Donate
Boards Manager: The Arduino IDE comes
supportLearn
for different boards.
to code — free Ascurriculum
3,000-hour you progress
through your journey, you’ll make use of
different boards and some of them may not be
supported by the IDE. The board manager tab
lets you install and manage packages required
to use these boards.

Library Manager: You can use libraries to

extend certain functionalities in code. Through
the library manager, you can install numerous
libraries that’ll help simplify the development
process for you.

Debugger: This is used for real time testing and

debugging of Arduino programs.

Search: You can use the search tool to find

specific keywords in your code.

Open Serial Monitor: You can use the serial

monitor to communicate with Arduino boards,
debug and test code, visualize data from your
boards, interact with user input, and so on.
We’ll look at the serial monitor in depth in a
different chapter.

Open Serial Plotter: The serial plotter is

mostly used for real-time visualization of
numerical data.
 Forum Donate

What Is an Arduino
Learn to code — free 3,000-hour curriculum

Sketch?
We mentioned the term “sketch” a couple of times in
the last section, but what is it? A sketch is a program
written with the Arduino programming language. It’s
another way of referring to a code file written for
Arduino projects.

The Arduino programming language is built upon the

C/C++ language so they both share similar syntax and
structure. You may come across resources that refer
to Arduino code as “embedded C” or “embedded C++”.

How to Upload Code to

an Arduino Board
To upload code to an Arduino board, you'll need both
hardware and software. The hardware is the board
which is the Uno board in our case, and the software is
the Arduino sketch in the IDE.

Here are the steps:

Step #1 – Connect the Arduino Forum Donate

Board Learn to code — free 3,000-hour curriculum

Connect the Arduino board to your computer using
the USB cable. Without this step, you can't go further.

Step #2 – Create a Sketch

Now it's time to launch the IDE and write some code.

Here's a code example that makes an LED blink:

int ledPin = 13;

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

void loop() {
digitalWrite(ledPin, HIGH);
delay(1000);
digitalWrite(ledPin, LOW);
delay(1000);
}

Don't worry if you don't understand the code — we'll

cover everything as we go further.
Step #3 – Select the Board and
Forum Donate

Port Learn to code — free 3,000-hour curriculum

You can select the board to upload your code to from
the IDE. Here's an image showing what that looks like:

Step #4 – Verify the Code

You can use the verify button to compile the code and
check for errors. If errors exist, you'll get an error
message to show you the possible cause.
 Forum Donate
Learn to code — free 3,000-hour curriculum

Image showing the verify button

Step #5 – Upload the Code

You can upload the code using the upload button (the
button after the verify button).

If there are no errors in your code, these steps will

help upload code to your board. If you've uploaded the
code above, you should have the built-in LED (it is
connected to pin 13 by design) on the Uno board
blinking.

In the next chapter, you'll learn the basics of the

Arduino programming language.
 Forum Donate

Chapter 2: Basics of
Learn to code — free 3,000-hour curriculum

Arduino
Programming
Before we dive into creating our own sketches and
tinkering, you have to understand the logic that make
these boards work as expected. To do that, you’ll have
to know how to code using the Arduino programming
language.

As discussed in the last chapter, the Arduino language

is built upon C/C++. You’ll begin this chapter by
learning the basics of programming. This will prepare
you for every other chapter that involves writing code.

I’ve created this chapter with beginners in mind. If

you’ve never written code before then this can serve
as a starting point for you. This doesn’t mean you’ll
learn how to code in C or C++. You’ll be learning how
to write Arduino code which shares similar syntax
with those languages.

At the end of this chapter, you should be able to

understand and write Arduino code.
 Forum
Variables and Data Types
Donate
Learn to code — free 3,000-hour curriculum

in Arduino
Variables and data types are used in most
programming languages to store and manipulate data.
You can think of variables as containers or storage
units. Data types, like the name implies, are the type of
data stored in variables.

In Arduino programming, you must specify the data

type of a variable before using it. That is:

dataType variableName = variableValue

There are different types of data types in Arduino, and

we’ll discuss each one along with code examples.

int Data Type in Arduino

The int data type is used to store integer values. The
Uno board has a 16-bit integer capacity so it can store
values that fall within the range of -32,768 to 32,767.

int redLED = 6;
 Forum Donate
In the code above, we created an integer variable
Learn to code — free 3,000-hour curriculum
called redLED with a value of 6.

The int data type can also store negative integers:

int redLED = -6;

long Data Type in Arduino

The long data type is similar to int but has a wider
range of integer values. It has a 32-bit integer limit
which falls within the range of -2,147,483,648 to
2,147,483,647.

long largeNumber = 6000;

float Data Type in Arduino

The float data type can be used to store numbers
with decimals. Float variables can store values up to
3.4028235E+38 and values as low as
-3.4028235E+38.
 float num = 10.5;
Forum Donate
Learn to code — free 3,000-hour curriculum

Although the float data type is mainly used for

decimal numbers, it can also accept whole numbers
(integers without decimals). But it'll always return a
float value. So if you store 10 in a float , it'll return
10.00.

String Data Type in Arduino

You can use the String data type to store and
manipulate text. You'll work with strings occasionally
to display information in the form of text when
building projects.

Here's a code example:

String greeting = "Hello World!";

The value of strings are nested within double

quotation marks as can be seen in the code above.

Note that when declaring a string, the "S" should

always be in uppercase.
 Forum
char Data Type in Arduino Donate
Learn to code — free 3,000-hour curriculum
The char data type stores single characters.

Here's an example:

char alphabet = 'A';

This is different from the String data type that can

store multiple characters.

There are two main differences between char and

String :

char uses single quotes ('A') while string uses

double quotes ("Arduino").

char stores single characters while string

stores multiple characters.

char can also accept integer values equivalent to the

ASCII value of letters:

char charValue = 65;

In the code above, we initialized a char Forum
variable with
Donate
the value ofLearn
65. to
When
code —printed to thecurriculum
free 3,000-hour serial monitor
(we'll talk about the serial monitor in Chapter 6: How
to use the Serial Monitor in Arduino), A will be
returned.

A is returned because 65 has an ASCII character of A.

bool and boolean Data Types in

Arduino
You can use both bool and boolean to store/denote
boolean values of either true or false .

bool roomIsCold = false;

Boolean values are mostly used with logical and

comparison operators, and conditional statements
(you'll learn about these later in this chapter) to
manipulate and control different outcomes in an
Arduino program.

byte Data Type in Arduino

The byte data type has an 8-bit unsigned integer limit
that ranges from 0 to 255. Unsigned means that it
can't store negative values. Forum Donate
Learn to code — free 3,000-hour curriculum

byte sensorValue = 200;

The byte data type isn't the only data type that can be
unsigned. You can also use the unsigned int ,
unsigned long , and unsigned char data types which
all have their respective positive integer ranges.

Operators in Arduino
Operators are symbols or characters that can be used
to perform certain operations on operands. An
operand is simply any value(s) an operator acts on.

There are different categories of operators in Arduino

like:

Arithmetic Operators
Arithmetic operators are used to perform
mathematical operations like addition, subtraction,
division, multiplication, and so on. Here are some
arithmetic operators you should know:
Addition(+) Operator Forum Donate
The addition operator,
Learn to code —denoted by the
free 3,000-hour + symbol, adds
curriculum

two operands together:

int a = 5;
int b = 10;

// we use addition operator to add a and b below

int c = a + b;

Serial.print(c);
// 15

Subtraction(-) Operator
The subtraction operator subtracts the value of one
operand from another operand. It is denoted by the -
symbol:

int a = 5;
int b = 10;

// we use subtraction operator to subtract b from a below

int c = b - a;

Serial.print(c);
// 5
Multiplication (*) OperatorForum Donate

You can useLearn

the to code — free 3,000-hour curriculum
multiplication operator ( * ) to
multiply two operands:

int a = 5;
int b = 10;

// we use multiplication operator to multiply a by b belo

int c = a * b;

Serial.print(c);
// 50

Division(/) Operator
The division operator divides one operand by another:

int a = 5;
int b = 10;

// we use division operator to divide b by a below

int c = b / a;

Serial.print(c);
// 2

Modulus (%) Operator

 Forumof a Donate
The modulus operator returns the remainder
division between
Learn to two operands:
code — free 3,000-hour curriculum

int a = 5;
int b = 10;

// we use division operator to divide b by a below

int c = b % a;

Serial.print(c);
// 0

Increment (++) Operator

The increment operator increases the value of a
variable by 1:

int num = 5;
num++;

Serial.print(num);
// 6

Decrement (--) Operator

The decrement operator decreases the value of a
variable by 1:
 Forum Donate
int num = 5;
Learn to code — free 3,000-hour curriculum
num--;

Serial.print(num);
// 4

Assignment Operators
Assignment operators are mainly used to assign
values to variables. You can also use them to update
the value of variables.

The assignment ( = ) operator is used for assigning and

updating variables. The = operator should not be
confused for "equal to" — they aren't the same. We'll
talk about the equal to ( == ) operator in the
Comparison Operators section.

Here's an example that shows how to use the

assignment operator:

int age = 1;

In the code above, we created a variable called age ,

and then assigned a value of 1 to it using the =
operator. Forum Donate
Learn to code — free 3,000-hour curriculum
But this isn't the only way to assign or update the
value of variables when using the = operator. You can
also use compound assignment operators.

Compound Assignment Operators

Compound assignment operators let you combine
arithmetic operators and the = operator. This method
provides a shorter way of writing code. Here is an
example:

int x = 5;
x += 5;

Serial.print(x)
// 10

In the code above, we created an x variable and

assigned a value of 5 to it. But on the second line,
you'd see that we combined the arithmetic addition
( + ) operator and the = operator to assign a new value
to x :

x += 5;
 Forum Donate
The line of code above
Learn to code —is the
free same as
3,000-hour this:
curriculum

x = x + 5;

So compound operators combine two operators and

let you do the same thing in a shorter way. There's
nothing wrong with either method.

Here are other compound operator examples:

int a = 10;
a -= 5; // Equivalent to a = a - 5 (a becomes 5)

int b = 10;
b *= 5; // Equivalent to b = b * 5 (b becomes 50)

int c = 10;
c /= 5; // Equivalent to c = c / 5 (c becomes 2)

int d = 10;
d %= 5; // Equivalent to d = d % 3 (d becomes 0)

Comparison Operators
You can use comparison operators to compare two
values/operands. Comparison operators return either
true (1) or false (0) depending on the Forum
relationshipDonate
between operands.
Learn to code — free 3,000-hour curriculum

Comparison operators can help you make decisions

based on their return values. You'll see them a lot
when we start building projects.

Here are the comparison operators you'll come across

occasionally:

Equal To (==) Operator

This operator compares the values of two variables. If
the values are the same, it returns true . If the values
are not the same, it returns false . Here's an example:

int x = 10;
int y = 5;

Serial.print(x == y)
// returns 0

The return value of x == y in the code above is 0

( false ) because the two variables are not the same.
Remember that the == operator returns 1 ( true ) only
when both variables have the same value.
Not Equal (!=) Operator Forum Donate
The not equal operator
Learn checks
to code — free whether
3,000-hour two values
curriculum

have different values. It's does the opposite of the ==

operator. That means it'll return 1 ( true ) if both
values are not of the same value and 0 ( false ) if both
values are the same.

Here's an example:

int x = 10;
int y = 5;

Serial.print(x != y)
// returns 1

Greater Than (>) Operator

The greater than ( > ) operator checks if the operand
on the left is greater than the operand on the right. If
the left operand is greater, it returns 1. If the left
operand is smaller, it returns 0.

int x = 10;
int y = 5;

Serial.print(x > y)
// returns 1
 Forum Donate
Learn to code — free 3,000-hour curriculum
Less Than (<) Operator
The less than ( < ) operator checks if the operand on
the left is less than the operand on the left. If the left
operand is smaller, it returns 1. If the left operand is
greater, it returns 0.

int x = 10;
int y = 5;

Serial.print(x < y)
// returns 0

Greater Than or Equal To (>=)

Operator
Just like the name, the >= operator checks if the
operand on the left is either greater than or equal to
the operand on the right. It returns 1 if the left
operand is greater than or equal to the right operand,
and 0 if it isn't.

"Or" implies that either of the conditions can be used.

If the left operand is not greater than the right
operand but is equal to the right operand, you'll still
get a value of 1.
 Forum Donate
Learn to code — free 3,000-hour curriculum
int x = 10;
int y = 5;

Serial.print(x >= y)
// returns 1

Less Than or Equal To (<=) Operator

The <= operator checks if the left operand is either
less than or equal to the right operand. If the left
operand is less than or equal to the right operand, it
returns 1, and returns 0 if the left operand is neither
less than nor equal to the right operand.

int x = 10;
int y = 5;

Serial.print(x <= y)
// returns 0

Logical Operators
Logical operators are used in most programming
languages to evaluate and determine the relationship
between variables.
Here are the three logical operators youForum
should know
Donate
for ArduinoLearn
programming:
to code — free 3,000-hour curriculum

Logical AND ( && ) Operator

The logical AND ( && ) operator returns 1 if both
statements are true.

int x = 10;

Serial.print((x > 5) && (x > 3));

// returns 1

The expression above — (x > 5) && (x > 3) —

returns 1 because both statements are true. That is, x
> 3 and x > 3 . If either or both of those statements
were false, then we'd have a return value of 0.

Logical OR (||) Operator

The logical OR ( || ) operator returns 1 if one of both
statements is true.

int x = 10;

Serial.print((x > 5) && (x > 15));

// returns 1
 Forum Donate
The code above returns
Learn to 1 although
code — free one of the
3,000-hour curriculum

statements is false. This is because the || operator

returns 1 if either or both statements are true.

Logical NOT (!) Operator

The NOT ( ! ) operator negates or reverses the value
of its operand. If the operand statement is true, it
returns false, and returns false if the operand is true.

Here's an example:

int x = 10;

Serial.print(!(x > 5));

// returns 0

The code above returns 0, but why? x > 5 is true so

the expected result is 1.

We got 0 because the ! operator reversed the return

value of the operand from 0 to 1.
Conditional Statements
Forum
inDonate
Arduino
Learn to code — free 3,000-hour curriculum

You can use conditional statements to make decisions

or execute code based on specific conditions. You can
combine conditional statements and logic (like
operators in the last section) to control how code is
executed.

Let's take a look at some conditional statements and

how to use them:

if Statement
The if statement is used to execute code if a
condition is true . Here's what the syntax looks like:

if (condition) {
// code to be executed if condition is true
}

In the syntax above, condition denotes a specified

logic. If the condition is true then the code in the
curly brackets will be executed. Here's an example:
 int x = 5;
Forum Donate
if (x < 10) { to code — free 3,000-hour curriculum
Learn
Serial.print("x is less than 10");
}

// x is less than 10

In the code above, we gave a condition— x < 10 —

and a block of code within curly brackets that prints "x
is less than 10". The code in the curly brackets will only
run if the condition is true.

This is the same as saying "if x is less than 10 then

print 'x is less than 10' to the serial monitor". Since x is
less than 10, the condition evaluates as true and we
get the message printed out.

But what if the condition is false ? The code in the

curly brackets won't run, so we'll need a different type
of logic to handle situations like that. We can do this
using the else statement.

else Statement
The else statement is used to execute code if a
condition is false .
 int score = 20;
Forum Donate
if (score Learn
> 50 to
) code
{ — free 3,000-hour curriculum
Serial.print("You passed the exam!");
} else {
Serial.print("You have to rewrite the exam!");
}

// You have to rewrite the exam

In the code above, the condition given is false . So the

code for the else statement will be executed because
the score variable is not greater than 50.

Remember: the code for the else statement only runs

when the condition is false . If the condition is true
then the code for the if statement will be executed.

else if Statement
You can use the else if statement to define multiple
conditions to be checked. Here's the syntax:

if (condition1) {
// code to be executed if condition1 is true
} else if (condition2){
// code to be executed if condition2 is true
} else {
// code to be executed if condition1 and con
}
 Forum Donate
Learn
In the syntax to code
above, — free are
there 3,000-hour curriculum (you can
two conditions
create more than two conditions). If condition1 is
true , then code in the curly bracket for condition1
will be executed.

If condition1 is false , then condition2 will be

evaluated. If condition2 is true , its block of code will
be executed.

If both condition1 and condition2 are false , the

else statement's code will be executed.

int score = 80;

if (score > 50 ) {
Serial.print("You passed the exam!");
} else if (score < 50) {
Serial.print("You have to rewrite the exam!");
} else {
Serial.print("No records for your exam score found!");
}

// You passed the exam!

switch-case Statement
In the last section, we saw how to create multiple
conditions using else if statements. Your code
 Forum
might become hard to read if you have many Donate
conditions. Learn
We can clean
to code it3,000-hour
— free up and make the code
curriculum

more readable using switch statements.

Here's what the syntax looks like:

switch (expression) {
case 1:
// Code to be executed if expression equals
break;
case 2:
// Code to be executed if expression equals
break;
case 3:
// Code to be executed if expression equals
break;
default:
// Code to be executed if expression doesn't
break;
}

Let's break the syntax down:

The expression is compared to the value of

each case .

When a case matches the expression , the

code for that case is executed.
 Forum
The break keyword stops the switch Donate
statement's iteration
Learn to once
code — free a match
3,000-hour for the
curriculum

expression has been found.

The code for the default keyword is executed

if none of the cases match the expression .

Here's an example:

int day = 2;

switch (day) {
case 1:
Serial.print("Monday");
break;
case 2:
Serial.print("Tuesday");
break;
case 3:
Serial.print("Wednesday");
break;
case 4:
Serial.print("Thursday");
break;
case 5:
Serial.print("Friday");
break;
case 6:
Serial.print("Saturday");
break;
case 7:
Serial.print("Sunday");
break;
default:
 Serial.print("Number out of range");
Forum Donate
}
Learn to code — free 3,000-hour curriculum
// Tuesday

The code above prints "Tuesday" because the

expression which has a value of 2 matches case 2 .

Loops in Arduino
You can use loops to execute code repeatedly until a
certain condition is met. You can also use loops to
iterate over a collection of data and execute code on
all elements of the collection.

There are different type of loops you can use in

Arduino like the for loop , while loop , and do-while
loop. Let's take a look at their syntax along with some
practical examples:

for loop
You can use the for loop to iterate through a
collection or execute code until a certain condition is
met. It is commonly used when you know the number
of times the loop is supposed to run.

Here's the syntax:

 Forum Donate
Learn to code — free 3,000-hour curriculum
for (initialization; condition; increment/decrement)
// code to be executed
}

There are three important keywords in the syntax

above:

initialization denotes an initial variable

(usually an integer) which specifies the starting
point of the loop.

condition is used to control the number of

times the loop is expected to run for. The loop
stops when the condition is false .

increment/decrement increases/decreases the

value of the initial variable after every
iteration.

Here's an example to help you understand the

keywords:

for (int i = 0; i < 11; i++){

Serial.println(i);
}
 // 0
Forum Donate
// 1
// 2 Learn to code — free 3,000-hour curriculum
// 3
// 4
// 5
// 6
// 7
// 8
// 9
// 10

In the loop above, we created an initial variable called

1 with a value of 0.

The condition stated i < 11 which implies that the

loop will continue to run as long as i is less than 11.

Using the increment operator i++ , we increased the

value of i by 1 every time the loop ran.

Lastly, we printed the value of i at every iteration. In

the serial monitor, you'll notice the numbers from 0 to
10 printed out. This is because after the number 10, i
is no longer less than 11 (the condition given), so the
loop terminates.

while loop
The while loop works just like the for Forum
loop — it Donate
executes code
Learnas
tolong asfree
code — the given condition
3,000-hour curriculum is true .

But its often used when the number of times the loop
is supposed to run is unknown.

Here's the syntax:

while (condition) {
// Code to be executed
}

In the syntax above, the code will continue to run until

the condition becomes false .

while (i < 11) {

Serial.println(i);
i++;
}

// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
 // 9
Forum Donate
// 10
Learn to code — free 3,000-hour curriculum

do-while Loop
The do-while loop is just like the while loop, but it
executes its code block first before checking the
validity of the condition given. That is, at the beginning
of the loop, the code in curly brackets will run first
even if the condition is false . After that, it starts
checking if the condition is true or false , just like a
normal loop.

In summary, the code for a do-while loop will run at

least once, irrespective of the condition given. Here's
an example:

do {
// code block to be executed
}
while (condition);

Here's the code example:

int i = 0;
 do {
Forum Donate
Serial.println(i);
i++; Learn to code — free 3,000-hour curriculum
} while ( i < 11);

// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
// 10

Arrays in Arduino
You can use arrays in Arduino to store multiple
variables of the same data type in a single variable.
Each element stored in an array can be accessed using
its index number.

Array Declaration
Declaring an array simply means to create one. You
can do that in Arduino using the syntax below:

dataType arrayName[arraySize]
 Forum Donate
In the syntax above:
Learn to code — free 3,000-hour curriculum

dataType represents the data types that'll be

stored in the array. For instance, if the data
type is int , then only integers can be stored in
the array.

arrayName denotes the name of the array.

arraySize denotes the number of elements

that can be stored in the array.

Here's an array declaration code example:

int ages[4];

In the code above, we created an array called ages .

The array can only store four elements with an int
data type.

Array Initialization
To initialize an array means to assign values to the
array. In the last section, we created an array called
ages . Now, let's assign some elements to it:
 Forum Donate
int ages[4] = {2, 4, 6, 8};
Learn to code — free 3,000-hour curriculum

You can see from the example above that there are
only four elements in the array — 2, 4, 6, 8. Assigning a
fifth element would throw an error because we
specified that the array can only have for integer
elements: int ages[4]; .

You can access the elements of the array using their

index number. Indexes start at zero (0) – so the first
element has an index of 0, the second element has an
index of 1, the third element has an index of 2, and so
on.

int ages[4] = {2, 4, 6, 8};

Serial.print(ages[0]);
// 2

As can be seen above, we accessed the first element

using the array name and the index of the element in
square brackets: ages[0] .

You can also assign and reassign values to a particular

element using its index:
 Forum Donate
Learn to code — free 3,000-hour curriculum
ages[0] = 10;

Note that you can declare and initialize an array at the

same time. I only divided them into separate sections
to help you understand what each term means.

Functions in Arduino
In the last chapter, we discussed some built-in
functions in Arduino that can be used to carry out a
variety of tasks related to Arduino hardware and
software components. All we did was write the
function name and pass in parameters where
necessary and we got the desired outcome.

For instance, the digitalWrite() function writes

values to digital pins using two parameters (the pin
number and the value to be sent to the pin). Under the
hood, some code logic handles that operation.

Let's assume that the logic required to send values to

digital pins was up to a hundred lines of code. Without
functions, you'll have to write those hundred lines
every time you wanted to send values to digital pins.
 Forum the Donate
Functions prevent you from having to reinvent
wheel. TheyLearn
alsotohelp you
code — freebreak your
3,000-hour code down into
curriculum

smaller, more readable and manageable parts.

Just like how built-in functions can be reused to

perform a particular task repeatedly, you can also
create your own functions for specific functionalities,
and that's exactly what you'll learn in this chapter.

How to Declare Functions in

Arduino
There are four main parts of a function in Arduino:

The type of data the function returns.

The name of the function.

The function parameter(s) which is optional.

The body of the function.

Here's what that looks like:

dataType functionName(optionalParameters) {
// body of the function
}
 Forum
So from the syntax above, dataType is the data typeDonate
the functionLearn
returns.
to codeIt
— can be int , curriculum
free 3,000-hour String , and so on.
A function that has no return statement uses the
void type as its data type.

The functionName is the name given to the function.

The name is used to call the function to execute the
logic defined in the body of the function. You'd see
words like "call", "fire", and "invoke" associated with
functions. They all mean the same thing — to execute
the function's logic.

optionalParameters are variables that you define

when creating a function. They enable functions to
accept external data which can be used within the
function body. Function parameters are defined along
with their data types. You'll understand this when we
look at some examples.

The body of the function is where all the logic goes to.
What the function does when it is invoked is written in
the body.

Now that we've seen the different parts of a function,

let's create some functions!
How to Declare a Function Forumwith Donate

the void
LearnType
to code — free 3,000-hour curriculum

In the last chapter, we discussed the void Setup()

and void loop() functions. They are two built-in
functions that you'll use in every Arduino sketch.
These functions are defined using the void keyword
because they return nothing

Here's what the syntax looks like for functions that

use the void type:

void functionName(optionalParameters) {
// code logic
}

In the syntax above, functionName denotes the name

of the function. We can use that name to call the
function in order to execute the code defined in the
function.

optionalParameters are used to pass external data to

the function while the code logic that runs when the
function is called is written between the curly
brackets.

Here's an example:
 Forum Donate
Learn to code — free 3,000-hour curriculum
// function declaration
void printName(String userName) {
Serial.println("Hello " + userName);
}

void setup() {
Serial.begin(9600);
}

void loop() {
printName("Ihechikara"); // function call
delay(1000);
}

In the code above, we created a function called

printName which accepts a string parameter called
userName . The function's task is to print "Hello " along
with whatever the parameter value is.

In the void loop() , we called the function and passed

a parameter to it: printName("Ihechikara") . In the
serial monitor, you'll see "Hello Ihechikara" printed.

To call a function, all you have to do is write the name

of the function with parenthesis: printName() .
Remember to pass in parameters when required:
printName("Ihechikara") .
 Forum
Using a parameter that has the wrong data type willDonate
result in an Learn
error.to For
code instance, we defined
— free 3,000-hour curriculuma string

parameter in our example. Using an integer will raise

an error because the function expects a string.

How to Declare a Function with a

Return Data Type
In this section, I'll use the int data type to show you
how functions declared without the void type are
used. The logic here is the same with other functions
that use the return statement.

// function declaration
int addNums(int a, int b) {

int result = a + b;
return result;
}

void setup() {
Serial.begin(9600);
}

void loop() {
Serial.println(addNums(2, 10)); // function call
delay(1000);
}
 Forum
In the code above, we declared a function with the Donate
int type: int
LearnaddNums(int b) {...} . This
a, intcurriculum
to code — free 3,000-hour

implies that the function is expected to return an

integer value.

The function's logic adds the value of the two

parameters ( a and b ) and returns their sum. We
used the return statement to return the sum of the
parameters.

We can now say that the task of the addNums function

is to return the sum of two given parameters. This can
be seen when we used the function in the void
loop() :

Serial.println(addNums(2, 10));

We called the function with two parameters and got

their sum printed out in the serial monitor.

What You Should Know About

the return Statement
In the last two sections, we saw how to use functions
in two different ways — functions that use the return
statement and functions that don't use it.
 Forum
Donate
But what if you used the return statement in a void
Learn to code — free 3,000-hour curriculum
function? Would that break the code? The answer is
no. I'll explain why.

The main use of the return keyword is to return a

value from the function, and then terminate the
function. Consider the example below:

int addNums(int a, int b) {

int result = a + b;
Serial.println(result);
return result;

// This part will be ignored

Serial.println("Hello World");
}

The function above takes in two parameters — a and b

— and returns their sum. You'll notice that we printed
"Hello World" after the return statement. The part of
the code that comes after the return statement will
not be executed because the function
terminates/stops its operation once it sees a return
statement.
 Forum that Donate
So you should always remember that anything
comes afterLearn
the toreturn statement
code — free 3,000-hour will be ignored.
curriculum

You can use the return statement in void functions

but it is a convention not to. We simply use the void
keyword to define functions that have no use for the
return statement.

Commonly Used Built-in

Functions in Arduino
Sketch
In this section, we’ll discuss some of the commonly
used built-in functions you’ll come across when
writing or reading Arduino code. We'll make use of
them in most of the upcoming chapters of this
handbook.

We'll begin with the two main parts of an Arduino

sketch — the setup() and loop() functions.

setup() and loop() Functions in

Arduino
You can use the setup() function to configure analog
and digital pins, initialize variables, and do other setup
functionalities. The setup() function is Forum
executed once
Donate
— when theLearn
board is powered
to code on orcurriculum
— free 3,000-hour reset.

The loop() function runs continuously. This part of

the sketch is where you write all the code logic. You
can use the loop() function to give the Arduino board
instructions on different components and sensors.

void setup() {
// put your setup code here, to run once:

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

pinMode() Function in Arduino

The pinMode() function is used to configure pins as
input or output pins. It can also be used to configure a
resistor to act as either a pull-up or pull-down resistor.
You'll understand more about this function in the
Sensors and Actuators chapter.

Syntax
 pinMode(pin, mode)
Forum Donate
Learn to code — free 3,000-hour curriculum

pin denotes the pin number on an Arduino

board.

mode denotes the configuration of the pin

which can be INPUT, OUTPUT, or
INPUT_PULLUP.

digitalRead() Function in
Arduino
You can use the digitalRead() function to read the
state of digital pins. It returns either 0 ( LOW ) or 1
( HIGH ).

Syntax

digitalRead(pin)

In the code above, pin denotes the pin number on an

Arduino board.

digitalWrite() Function in
Arduino
The digitalWrite() function assigns orForum
writes values
Donate
(either HIGHLearn
or toLOW ) to
code digital
— free pins. curriculum
3,000-hour

Syntax

digitalWrite(pin, value)

pin denotes the pin number on an Arduino

board.

value denotes the value to be assigned to

pin . Can be HIGH or LOW .

analogRead() Function in Arduino

The analogRead() function reads values from analog
pins and returns values that fall within the range of 0
and 1023.

Syntax

analogRead(pin)

In the code above, pin denotes the pin number on an

Arduino board.
 Forum Donate
Learn to code — Function
analogWrite() in
free 3,000-hour curriculum

Arduino
This function writes or assigns an analog value to a
pin.

Syntax

analogWrite(pin, value)

pin denotes the pin number on an Arduino

board.

value denotes the value to be assigned to

pin . Range from 0 to 255.

Serial Functions in
Arduino
Serial communication enables an Arduino board to
communicate with the computer and other devices
using the built-in serial monitor. Here are some of the
commonly used functions:

Serial.begin()
The Serial.begin() function initializesForum
serial Donate
communication.
Learn toItcode
is the first
— free function
3,000-hour you use when
curriculum

working with the serial monitor. The function takes in

a baud rate as its parameter.

In this case, baud rate represents the rate or speed of

data transfer in serial communication.

Here's the syntax:

Serial.begin(baudRate)

Serial.print() and
Serial.println()
You can use the print() and println() functions to
print data to the serial monitor.

print(val)
println(val)

In the code above, val denotes the value to be

printed.
 Forum
We'll talk more about serial communication in Donate
Chapter 6: How tocode
Learn to use—the Serial Monitor
free 3,000-hour in Arduino.
curriculum

delay() Function in Arduino

You can use the delay() function to pause the
Arduino program for a specified amount of time.
Here's what the syntax looks like:

delay(ms)

In the code above, ms denotes the specified time in

milliseconds.

Chapter 3: How to
Use Digital Pins in
Arduino
Digital pins are used to send and receive digital signals
in two states — HIGH and LOW . The digital pins on a
Arduino board can be configured as either input or
output pins.
 Forum
These states can also be represented using numbersDonate
(1 for HIGH Learn
and to
0 code
for — free),3,000-hour
LOW or in volts (V) (5V for HIGH
curriculum

and 0V for LOW ).

The number and arrangement of pins differ in various

Arduino boards, but they serve the same purpose. So if
you understand how to use them in this chapter, you
won't have a problem working with them in other
boards.

The Uno board has 14 digital pins numbered from 0 to

13. Although each pin can be configured to serve as
either a digital input or output pin, some of them come
with extra functionalities like:

Pins 0 (RX) and 1 (TX) enable the Arduino

board to communicate serially. RX receives
while TX sends.

Pins that have the tilde (~) symbol beside them

support PWM (Pulse Width Modulation)
signals. This means that you can use these pins
like analog pins (to receive analog values).

Pins 2 and 3 can be used for interrupt-based

functionalities.
How to Configure Digital
Forum Donate

Pins as Input or Output

Learn to code — free 3,000-hour curriculum

Pins
When a digital pin is configured as an INPUT pin, it
serves as a point for receiving information from
components. This way you get data from sensors,
electronic components, and so on.

You can use the pinMode() function to configure a pin

to serve as either an INPUT or OUTPUT pin. Note that
the pins on an Uno board are set to INPUT by default
so if you don't specify prior to using them, they'll serve
as input pins.

In this section, you'll learn how to use digital pins as

both input and output pins. You'll start by learning
about them individually, and then see how to combine
input and output signals to build a mini project.

We'll start with INPUT.

Digital Pins as INPUT

The information or signal sent to input pins can be
read using the digitalRead() function. In this section,
 Forumfrom aDonate
you'll learn how to configure and read signals
digital inputLearn
pin to
using different
code — built-in
free 3,000-hour functions.
curriculum

We'll use the following hardware components:

Arduino Uno.

Breadboard.

Pushbutton.

Jumper wires.

Here's the diagram for the connection:

Configuration diagram – INPUT

Here's the code:

 int pushBtn = 7;
Forum Donate
int push_btn_state;
Learn to code — free 3,000-hour curriculum

void setup(){
pinMode(pushBtn, INPUT_PULLUP);
Serial.begin(9600);
}

void loop(){
push_btn_state = digitalRead(pushBtn);
Serial.println(push_btn_state);
delay(1000);
}

Let's break the code down.

We started by creating two integer variables —

pushBtn and push_btn_state :

int pushBtn = 7;
int push_btn_state;

pushBtn was assigned a value of 7. We used this value

to denote pin 7 on the Arduino board. We declared
the push_btn_state variable but didn't assign any
value to it because we'll use it to store the value of the
push button later.
In our setup() function, we configured Forum
the push Donate
button to act as to
Learn ancode
input pin
— free using the
3,000-hour pinMode()
curriculum

function:

pinMode(pushBtn, INPUT_PULLUP);

The function took in two parameters — the pushBtn

variable which denoted pin 7, and INPUT_PULLUP
which sets the pin as an input with a pull-up resistor.

We also initialized the serial monitor using

Serial.begin(9600) .

At this point, we've configured the Arduino software

and hardware to recognize pin 7 as an input pin.

Next, we used the digitalRead() function to read

signals coming from pin 7. Remember the
push_btn_state variable we created? That's where
we stored the signal:

push_btn_state = digitalRead(pushBtn);
 Forum
After that, we printed the value being read from pinDonate
7
to the serialLearn
monitor
to codeusing
— free 3,000-hour curriculum

Serial.println(push_btn_state); .

When you open the serial monitor, you'll see 1 being

printed out repeatedly. This is the initial state of the
pushbutton using a pull-up resistor. When you press
down the pushbutton, the value will become 0. When
you release the button, the value will become 1.

0 denotes LOW while 1 denotes HIGH . With this

example, you should understand how to configure,
read, and display signals from an input pin.

Digital Pins as OUTPUT

The main use of an output pin is to send out signals.
Since we're working with digital output, we can send
either HIGH (5V) or LOW (0V) signals. We can do this
for digital pins using the digitalWrite() function.

In this section, we'll use a LED (Light Emitting Diode)

to demonstrate how to configure and send signals to
components.

Here are the components we'll use:

Arduino Uno.
 Red LED. Forum Donate

1k OhmLearn to code — free 3,000-hour curriculum

resistor.

Jumper wires.

Breadboard.

Here's the circuit diagram:

Configuration diagram – OUTPUT

int RedLED = 8;

void setup(){
pinMode(RedLED, OUTPUT);
}

void loop(){
digitalWrite(RedLED, HIGH);
delay(1000);
digitalWrite(RedLED, LOW);
 delay(1000);
Forum Donate
}
Learn to code — free 3,000-hour curriculum

In the code above, we configured the red LED, which is

connected to pin 8 on the Uno board, as an output pin
using the pinMode() function.

We then used the digitalWrite() function to send

signals to the pin:

digitalWrite(RedLED, HIGH);
delay(1000);
digitalWrite(RedLED, LOW);
delay(1000);

With the HIGH parameter, we send 5V to the pin

which makes the LED come on. With LOW , we send 0V
which turns the LED off. So the LED comes on and off
continuously with a delay of 1000 milliseconds. This
example is commonly known as the "BLINK" example.

Digital I/O Project

Now that we've understood how to send and receive
digital signals using Arduino, let's combine both of
them to build an interactive project.
 Forum Donate
The idea is to control an LED using a pushbutton.
Learn to code — free 3,000-hour curriculum
When you press the button, the LED goes off, and
comes back on when you release the button.

We'll combine the components used in the previous

examples:

Arduino Uno.

Red LED.

1k Ohm resistor.

Pushbutton.

Jumper wires.

Breadboard.

Configuration diagram - INPUT and OUTPUT project

Here's the code: Forum Donate
Learn to code — free 3,000-hour curriculum

int pushBtn = 7;
int push_btn_state;
int RedLED = 8;

void setup(){
pinMode(pushBtn, INPUT_PULLUP);
pinMode(RedLED, OUTPUT);
}

void loop(){
push_btn_state = digitalRead(pushBtn);

if (push_btn_state == 1) {
digitalWrite(RedLED, HIGH);
} else {
digitalWrite(RedLED, LOW);
}
}

Here's a breakdown of the code above:

First, we connected the pushbutton to pin 7 and the

red LED to pin 8.

Then we configured both pins — pin 7 as input, and pin

8 as output.

Next, we read the value of the pushbutton using the

digitalRead() function and stored the value in a
variable called push_btn_state . Forum Donate
Learn to code — free 3,000-hour curriculum
Using an if statement, we checked for the state of
the pushbutton. When push_btn_state is not being
pushed down, it has a value of 1 ( HIGH ). We send 5V to
the LED using digitalWrite() .

When push_btn_state is pushed down, it has a value

of 0, and we send 0V to the LED which turns it off.

Chapter 4: How to
Use Analog Pins in
Arduino
Analog pins can be used to receive and send voltage
values from/to different sensors and components.
Unlike digital signals that fall within two states of 0
( LOW ) and 1 ( HIGH ), analog values have a wider range
of values from 0 to 1023.

The Uno board has six analog pins — A0, A1, A2, A3,
A4, and A5. These pins are INPUT pins by default.

Similar to digital pins, there are in-built functions for

receiving and sending analog voltage signals. You can
 Forum analog
use the analogRead() function to read/receive Donate
values fromLearn
pinstowhile
code —the analogWrite()
free 3,000-hour function
curriculum

can be used to write to specific pins.

Note that the analogWrite() function doesn't write

or send analog values to analog pins. It sends analog
voltage values (that get converted to digital signals) to
digital pins that support PWM (Pulse Width
Modulation).

You can find PWM digital pins on the Arduino board

by the (~) symbol beside them. On the Uno board,
there are pins 3, 5, 6, 9, 10, and 11.

In the project for this section, you'll learn how to

adjust the brightness of an LED using a potentiometer.
We'll use the potentiometer as an input component,
and send its voltage to an LED to increase/decrease
the LED's brightness.

Here are the components we'll use:

Arduino Uno.

Yellow LED.

Potentiometer.

1k Ohm resistor.
 Jumper wires. Forum Donate
Learn to code — free 3,000-hour curriculum
Breadboard.

Here's the circuit diagram:

Configuration diagram

Here's the code for the circuit:

int potentiometer = A0;

int pot_value = 0;
float pot_in_PWM;
int yelowLED = 6;

void setup(){
pinMode(potentiometer, INPUT);
pinMode(yelowLED, OUTPUT);
}

void loop(){
pot_value = analogRead(potentiometer);
 pot_in_PWM = pot_value * (255.0 / 1023.0);
Forum Donate
Learn to code — free
analogWrite(yelowLED, 3,000-hour curriculum
pot_in_PWM);
}

In the code above, we set the potentiometer

(connected to analog pin A0) as an input component.
The yellow LED (connected to digital pin 6) was set as
an output component. The LED is connected to a
PWM pin because we'll be sending analog values to it.

Using the analogRead() function, we got the value of

the potentiometer and stored it in a variable called
pot_value . The potentiometer returns values from 0
to 1023.

We then converted the values returned by the

potentiometer to a range of 0 to 255 which
corresponds with PWM values. This is because the
analogWrite() function sends PWM values that fall
within that range (0 to 255). The new range of values
was stored in a variable called pot_in_PWM .

Lastly, we used the analogRead() function to send

PWM values to the LED: analogWrite(yelowLED,
pot_in_PWM) .
When you verify and upload the code toForum
your Arduino
Donate
board, you'llLearn
be able
to codeto
— control the brightness
free 3,000-hour curriculum of the

LED by turning the potentiometer's knob.

Chapter 5: How to
Use Sensors and
Actuators in
Arduino
Sensors and actuators play a crucial role in developing
projects using Arduino. They help microcontrollers get
information about changes in the physical
environment, and make decisions based on that
information.

The goal of this chapter is to help you understand the

difference between sensors and actuators, and how to
use them. Of course, there are numerous sensors and
actuators, but we'll focus on just a few. You should be
able to explore other sensors on your own at the end
of this chapter.

We'll first talk about what sensors are, types of

sensors, and how to work with them using code. We'll
 Forumby
then do the same for actuators, and conclude Donate
looking at an example
Learn to code —that uses both
free 3,000-hour sensors and
curriculum

actuators in a project.

Let's get started!

What are Sensors in

Arduino?
A sensor is a device that listens for or detects changes
in the environment. Sensors convert the information
they detect in the physical environment to electrical
signals which are then sent to the microcontroller (the
brain of the board).

You can look at sensors like the human sense organs —

we use them to gather information about our
environment. Each sense organ (like eyes and ears) in
the human body has a specific function and mode of
operation that's different from other organs.

In the same manner, sensors in Arduino have their

specific functions and use cases. For example, we have
sensors that can measure and detect temperature,
motion, moisture, and so on.
Types of Sensors in Arduino
Forum Donate

Here are some

Learncommonly
to code — freeused sensors
3,000-hour you'll come
curriculum

across when working with Arduino:

Temperature sensor: Measures the

temperature and humidity of the environment.

Light-Dependent Resistor (LDR):

Measures/senses the intensity of light.

Ultrasonic sensor: Measures the distance of an

object from the sensor.

Motion sensor: Generally detects motion by

sensing changes in infrared energy/radiation.

Soil moisture sensor: Measures the moisture

level of the soil.

Water sensor: Measures water level/detects

water, and so on.

There are other types of sensors that you can use with
Arduino, but we'll just focus on two: the LDR (light-
dependent resistor) and ultrasonic sensor.

With the examples in this section, you'll be able to

explore how other sensors work on your own.
How to use the Light-Dependent Forum Donate

ResistorLearn
(LDR) in3,000-hour
to code — free Arduino curriculum

The light-dependent resistor (LDR), also known as a

photoresistor, is an electronic component that has
varying levels of resistance depending on the intensity
of light.

Basically, you can use this sensor to sense light. You

can do cool things with it like creating an automated
lighting system that turns on electric lights in your
house when it's dark, or a weather station that tracks
and monitors sunlight, and so on.

A LDR usually looks like this:

Diagram of an LDR

Here's what the circuit connection looks like:

 Forum Donate
Learn to code — free 3,000-hour curriculum

Configuration diagram

In the circuit above, one leg of the LDR is connected to

5V (volts). The other leg is connected to a 1K Ohm
resistor — one end of the resistor is connected to
ground (GND) while the other end is connected to an
analog pin (A1 in our circuit).

Here's the code:

int ldrPin = A1;

int ldrValue;

void setup() {
pinMode(ldrPin, INPUT);
Serial.begin(9600);
}

void loop() {
ldrValue = analogRead(ldrPin);
Serial.println(ldrValue);
 delay(1000);
Forum Donate
}
Learn to code — free 3,000-hour curriculum

In the code above, we created a variable called ldrpin

with a value of A1 . This denotes the connection made
in the circuit where one leg of the LDR is connected to
the analog pin. This pin will help us know the value of
the sensor.

We then created an ldrValue variable which will be

used to store the value of the sensor.

In the setup() function, we set the LDR as an INPUT

pin. We also initialized the serial monitor.

Next, we read the value of the LDR using the

analogRead function, and stored the value in the
ldrValue variable:

ldrValue = analogRead(ldrPin);

Lastly, we printed the read value to the serial monitor

with a delay of 1000 milliseconds (one second).
 Forum
At this point, if you increase the exposure of light onDonate
the LDR, the value
Learn increases.
to code If you curriculum
— free 3,000-hour decrease the light
intensity or cover the sensor to block off light, the
value will decrease or become zero, respectively.

How to Use the Ultrasonic

Sensor in Arduino
The ultrasonic sensor is generally used to measure the
distance of objects. You can use this sensor in a lot of
applications like:

Home automation (you can perform certain

actions when the presence of an object/human
is sensed, like turning on lights in a dark room).

Automated doors.

Security systems.

Measurement of distance, and so on.

Just like other sensors, there are various types. In this

example, we'll use the HC-SR04 ultrasonic sensor.
Don't worry, the working principle is the same. So if
you understand how to use this one, you can configure
and use other types of ultrasonic sensors you come
across.
 Forum
Here's what the circuit diagram looks like: Donate
Learn to code — free 3,000-hour curriculum

Configuration diagram (from

https://howtomechatronics.com/tutorials/arduino/ultrasonic-
sensor-hc-sr04/)

The sensor has four pins — VCC, Trig, Echo, and GND.

The VCC pin is connected to 5V on the Uno

board

The Trig pin is connected to digital pin 9.

The Echo pin is connected to digital pin 10.

The GND pin is connected to GND on the Uno

board.
 ForumsensorDonate
The trig pin is used to "trigger" the ultrasonic
while the echo
Learnpin is used
to code — freeto distance
3,000-hour of objects based
curriculum

on the amount of time it takes for ultrasonic

waves/signals to bounce back from an object.

Here's a code example:

int trigPin = 9;
int echoPin = 10;

long duration, distance;

void setup() {
Serial.begin(9600);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
}

void loop() {
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

duration = pulseIn(echoPin, HIGH);

distance = (duration / 2) * 0.0343;

Serial.print("Distance: ");
Serial.print(distance);
Serial.println(" cm");

delay(1000);
}
 Forum Donate
In the code above, the trig pin denotes digital pin 9,
Learn to code — free 3,000-hour curriculum
and the echo pin denotes digital pin 10.

We declared two variables — duration and distance —

to be used to store their respective values.

We triggered the sensor by sending the HIGH signal to

the trigger pin for 10 microseconds. Without this, the
sensor might not work:

digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

We measured and stored the duration of the

ultrasonic pulse/signals using the pulseIn(echoPin,
HIGH) function and stored it in the duration variable.

We then calculated the duration in centimeters and

stored it in the distance variable.

Lastly, we printed the distance to the serial monitor

with a delay of 1000 milliseconds.

At this point, you can place an object closer to or

farther away from the sensor and see the value of the
 Forum
distance of the object change in the serial monitor. Donate
Learn to code — free 3,000-hour curriculum

What are Actuators in

Arduino?
Actuators in Arduino are components that convert
electrical signals into physical/mechanical motion.

Here are some actuators:

LED (Light Emitting Diode): Used as light/visual

indicators.

Buzzer: Used to produce sound.

Relay modules: Used to control high voltage

devices.

LCD (Liquid Crystal Display): Used as visual

display for text, images, sensor data, and so on.
We'll dedicate a separate chapter to displays.

Servo motors: Used to control angular or

rotational motion (an example is the movement
of a robotic arm).

We'll focus on the buzzer and LED in this section.

How to use LEDs in Arduino

 Forum
LEDs are usually the first components you learn about
Donate
in Arduino. Learn
There are —
to code easy to connect
free 3,000-hour and use.
curriculum

Here's what an LED looks like:

Here's the circuit connection:

In the circuit above, the longer leg of the LED (the

anode or positive leg) is connected to digital pin 7.
 Forum Donate
The shorter leg (cathode) is connected to ground.
Learn to code — free 3,000-hour curriculum

Here's the code:

int redLED = 7;

void setup() {
pinMode(redLED, OUTPUT);
}

void loop() {
digitalWrite(redLED, HIGH);
delay(1000);
digitalWrite(redLED, LOW);
delay(1000);
}

The code above will make the LED blink once the code
has been uploaded.

How to use a Buzzer in Arduino

You can use buzzers to produce sound. There are
generally two types of buzzers: active and passive
buzzers.

Active buzzers usually have a predefined type of

sound that they produce when voltage is supplied to
them. The sound cannot be modified. Active buzzers
have an internal circuit that triggers theForum
sound Donate
production.Learn to code — free 3,000-hour curriculum

Passive buzzers are a bit more flexible when it comes

to producing sound because they rely on external
signals. This means that you can determine the
frequency (or frequencies) of the sound produced by
the buzzer.

Buzzers can be used in different applications like:

Alarm systems.

Sound indictor for home appliances.

Doorbells.

Communication devices to denote the

start/end of a signal communication, and so on.

We'll work with the passive buzzer because of its

flexibility. This is what it looks like:
 Forum Donate
Learn to code — free 3,000-hour curriculum

The buzzer has a positive and negative terminal. The

positive is connected to a digital pin while the negative
is connected to ground.

Here's the circuit diagram:

In this example, we'll use the buzzer to produce the

DO, RE, MI, FA, SOL, LA, TI music notes sound.

Here's the code:

 Forum Donate
Learn to code — free 3,000-hour curriculum
int buzzerPin = 7;

int notes[] = {262, 294, 330, 349, 392, 440, 494};

int noteDurations[] = {400, 400, 400, 400, 400, 400, 400

void setup() {
pinMode(buzzerPin, OUTPUT);
}

void loop() {
for (int i = 0; i < 8; i++) {
tone(buzzerPin, notes[i], noteDurations[i]);
delay(noteDurations[i] + 50);
noTone(buzzerPin);
}

delay(1000);
}

In the code above, we used the buzzerPin variable to

denote pin 7 on the Uno board.

We then created an array called notes[] which stores

the respective frequency of each note, and another
array called noteDurations which stores the duration
of each note as they're being produced by the buzzer.

In the void loop() function, we looped through each

note a played them using the tone() function. The
 Forum
function takes in three parameters — the pin Donate
connected to the
Learn to buzzer, the
code — free frequency,
3,000-hour and the
curriculum

duration.

We used the noTone() function to stop the generation

of sound. Lastly, we added a delay of 1000
milliseconds which is the amount of time it'll take to
play the notes from the start after the last note has
been played.

If you've followed along up to this point, then you

should have the DO, RE, MI, FA, SOL, LA, TI music
notes playing through the buzzer.

Arduino Sensor and

Actuator Example
Now that you understand what sensors and actuators
are and how to use them, let's use them together in
one project.

In many embedded systems, sensors and actuators

work together to get a specific task/functionality
done. Here's how that works:

A sensor detects/senses changes in the

environment, and sends signals to the
 Forum
microcontroller to notify it of the detected Donate
changes.Learn to code — free 3,000-hour curriculum

The microcontroller processes the signals from

the sensor. Depending on the existing logic
(defined in the code), it sends signals to the
actuator.

The actuator converts the signal from the

microcontroller to physical/mechanical motion.

Let's demonstrate these using an example. The idea

here is to turn on an LED in a dark environment and
turn it off when there's enough light.

The sensor will be the LDR sensor, the microcontroller

will be the Arduino Uno board/software, and the
actuator will be the LED.

Here's the circuit diagram:

 Forum Donate
Learn to code — free 3,000-hour curriculum
Here's the code:

int redLED = 7;

int ldrPin = A1;

int ldrValue;

void setup() {
pinMode(ldrPin, INPUT);
pinMode(redLED, OUTPUT);
Serial.begin(9600);
}

void loop() {
ldrValue = analogRead(ldrPin);

if (ldrValue > 200) {

digitalWrite(redLED, LOW);
} else if (ldrValue < 200) {
digitalWrite(redLED, HIGH);
}

Serial.println(ldrValue);
delay(1000);
}

As usual, we created variables to represent the

Arduino pins connected to the LED and LDR. We then
set the LDR as INPUT and the LED as output in the
setup() function.
We read the value of the LDR using the Forum Donate
analogRead()
function and stored
Learn it—infree
to code the3,000-hour
ldrValue variable.
curriculum

Next, we used the an if statement to check the value

of the LDR.

If the value is greater than 200, we turn off the LED. If

the value is less than 200, we turn on the LED.

Chapter 6: How to
Use the Serial
Monitor in Arduino
The serial monitor is a useful tool for every Arduino
builder. You can use it for a variety of tasks like:

Debugging and testing code/components.

Serial communication between the Arduino

board and the computer.

Display sensor and component data and

readings.

In this chapter, you'll learn how to initialize and use

the serial monitor using the Arduino IDE. You'll learn
 Forum
about different built-in functions that can be used toDonate
send and receive
Learn todata
code —between the curriculum
free 3,000-hour Arduino board and
the computer.

Lastly, you'll build a project that uses values sent from

the serial monitor to power specific LEDs connected
to the Arduino board.

How to Initialize the Serial

Monitor With
Serial.begin()
You can use the Serial.begin() function to initialize
the serial monitor. It takes in the baud rate as its
parameter. Here's what the syntax looks like:

Serial.begin(baudRate)

The baud rate is the speed of data transfer between

the Arduino board and the computer or any other
device communicating with the Arduino board
through the serial monitor.

The most commonly used baud rate is 9600, but you'll

also come across resources that make use of 115200,
 Forum
57600, and 38400, and so on. Whichever baud rate Donate
you specifyLearn
in the — free 3,000-hourfunction
Serial.begin()
to code curriculum should

always match the baud rate seen in the serial monitor

window.

For example, we can initialize the serial monitor in the

IDE using the Serial.begin() function like this:

void setup() {
Serial.begin(9600);

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

In the code above, using the Serial.begin() function,

we initialized the serial monitor in the setup()
function with a baud rate of 9600.

At this point, nothing is happening. You can verify that

the baud rates match by opening the serial monitor
window. Once you have it open, you should have the
serial monitor appear at the base of the IDE. You'll see
the baud rate of the serial monitor within the window,
usually written like "9600 baud".
 Forum Donate
Learn to code — free 3,000-hour curriculum

Image showing baud rate

If you're using an older version of the IDE, the serial

monitor may pop up as a separate window. The
functionality is still the same.

Now that we've initialized the serial monitor, let's see

how to send and receive data with it.

How to Send Data with

Serial Monitor
You can use different built-in functions reserved for
serial communication in Arduino. We won't discuss all
the built-in serial functions in Arduino – we'll just look
 Forum
at some you'll use/come across regularly. You can see
Donate
more functions
Learn here.
to code — free 3,000-hour curriculum

print() and println() Functions

The print() and println() functions both print data
to the serial monitor. The difference between the two
is that print() prints data on the same line while
println() prints each data on a new line.

Here are some examples:

void setup() {
Serial.begin(9600);
}

void loop() {
Serial.print("Hello");
delay(1000);
}

In the code above, we used the print() function to

print "Hello" to the serial monitor repeatedly with a
delay of 1000 milliseconds. Here's what the output
looks like in the serial monitor:
 Forum Donate
Here's another
Learnexample using
to code — free the println()
3,000-hour curriculum function:

void setup() {
Serial.begin(9600);
}

void loop() {
Serial.println("Hi");
delay(1000);
}

Here's the output in the serial monitor:

How to Receive Data with

Serial Monitor
 Forum
We'll discuss four functions in this section — Donate
available() , readString()
Learn , parseInt()
to code — free 3,000-hour , and
curriculum

parseFloat() . You can read up on other serial

functions here.

available() Function
The Serial.available() function checks the number
of characters in the serial port. It is mostly use to run
code only when data is available in the serial monitor.

Here's a code example:

int userInput;

void setup(){
Serial.begin(9600);
}

void loop(){
if (Serial.available() > 0) {
userInput = Serial.parseInt();

Serial.println(userInput);
}

In the code above, the code block in the if statement

will not run until the number of characters in the serial
monitor is greater than 0. Forum Donate
Learn to code — free 3,000-hour curriculum
When you initialize the serial monitor, the number of
readable characters will be zero because there is no
data available yet. The Serial.available() function
checks and returns the number of characters available
in the serial monitor. So it is used to create logic that
only lets code be executed when data is available.

readString() Function
You can use the readString() function to read
characters from the serial monitor. It returns a string
object so whatever values/characters you input in the
serial monitor will be seen as string values when using
the readString() function.

String userInput;

void setup(){
Serial.begin(9600);
}

void loop(){
if (Serial.available() > 0) {
userInput = Serial.readString();

Serial.println(userInput);
}
 Forum Donate
}
Learn to code — free 3,000-hour curriculum

parseInt() Function
The parseInt() function returns valid integer values
from incoming serial data. Non integer values will be
returned as 0.

int userInput;

void setup(){
Serial.begin(9600);
}

void loop(){
if (Serial.available() > 0) {
userInput = Serial.parseInt();

Serial.println(userInput);
}

parseFloat() Function
The parseFloat() function returns valid floating
point numbers from incoming serial data.
 float userInput;
Forum Donate
Learn to code — free 3,000-hour curriculum
void setup(){
Serial.begin(9600);
}

void loop(){
if (Serial.available() > 0) {
userInput = Serial.parseFloat();

Serial.println(userInput);
}

Serial Monitor Project

In this section, you'll build a project that uses string
values from the serial monitor to turn on LEDs. We'll
make use of some of the serial functions discussed in
previous sections.

Here's the circuit diagram:

 Forum Donate
Learn to code — free 3,000-hour curriculum

In the circuit diagram above, we have three LEDs. The

red LED is connected to pin 6, the blue LED to pin 5,
and the yellow LED to pin 4.

Here's the code:

int redLED = 6;
int blueLED = 5;
int yellowLED = 4;

String userInput;

void setup(){
pinMode(redLED, OUTPUT);
pinMode(blueLED, OUTPUT);
pinMode(yellowLED, OUTPUT);
Serial.begin(9600);

Serial.println("Choose an LED to turn on from the list

Serial.println("red");
Serial.println("blue");
Serial.println("yellow");
}
 Forum Donate
void loop(){
Learn to code — free 3,000-hour curriculum
if (Serial.available() > 0) {

userInput = Serial.readString();

if (userInput == "red") {
digitalWrite(redLED, HIGH);
digitalWrite(blueLED, LOW);
digitalWrite(yellowLED, LOW);
}

if (userInput == "blue") {
digitalWrite(redLED, LOW);
digitalWrite(blueLED, HIGH);
digitalWrite(yellowLED, LOW);
}

if (userInput == "yellow") {
digitalWrite(redLED, LOW);
digitalWrite(blueLED, LOW);
digitalWrite(yellowLED, HIGH);
}

Let's break down the code above.

Just like the connection in the circuit diagram, we

initialized the three LEDs with their respective pin
numbers. We also created a string variable called
userInput that will be used to store theForum
data from the
Donate
serial monitor:
Learn to code — free 3,000-hour curriculum

int redLED = 6;
int blueLED = 5;
int yellowLED = 4;

We then configured the three LEDs as output pins

using the pinMode() function:

pinMode(redLED, OUTPUT);
pinMode(blueLED, OUTPUT);
pinMode(yellowLED, OUTPUT);

We initialized the serial monitor with a baud rate of

9600, and printed some strings to give users a hint at
the expected values to be used in the serial monitor:

Serial.begin(9600);

Serial.println("Choose an LED to turn on from the list be

Serial.println("red");
Serial.println("blue");
Serial.println("yellow");
 Forum Donate
At this point, you'll have an output like this in the serial
Learn to code — free 3,000-hour curriculum
monitor:

Using the Serial.available() function, we check for

availability of serial data before running the code in
the if statement:

if (Serial.available() > 0) {
...
}

The next thing we did was to read and return the

incoming data as string values, and store the data in
the userInput variable. We did that using the
readString() function:

userInput = Serial.readString();
Lastly, we used if statements to check Forum
which LED Donate
color value Learn
the user has
to code typed
— free in/sent
3,000-hour through the
curriculum

serial monitor, then turn on/off the respective LEDs:

if (userInput == "red") {
digitalWrite(redLED, HIGH);
digitalWrite(blueLED, LOW);
digitalWrite(yellowLED, LOW);
}

if (userInput == "blue") {
digitalWrite(redLED, LOW);
digitalWrite(blueLED, HIGH);
digitalWrite(yellowLED, LOW);
}

if (userInput == "yellow") {
digitalWrite(redLED, LOW);
digitalWrite(blueLED, LOW);
digitalWrite(yellowLED, HIGH);
}

If you type and send red through the serial monitor,

the red LED comes on while the others goes off. The
same logic applies to sending blue or yellow through
the serial monitor.
Chapter 7: How to
Forum Donate
Learn to code — free 3,000-hour curriculum

Use Displays in
Arduino
You can use display components in Arduino to
represent data visually in different formats like text,
images, and so on.

Displays provide an alternative to showing data other

than the serial monitor. You can use them to display
sensor values, instructions to users, user input, and so
on.

There are various types of display components when it

comes to building with Arduino but we'll focus on the
LCD (Liquid Crystal Display).

To be more specific, we'll use the 16 x 2 LCD

(HD44780). This is what it looks like:
 Forum Donate
Learn to code — free 3,000-hour curriculum

From the image above, there are sixteen pins with

different values. We'll use most of these pins to make
connections to the Uno board which will enable us use
and control the component.

There are generally two ways of connecting the LCD

— using the built-in library or using a third-party
library.

With the built-in LiquidCrystal library, you'll make

use of about 12 pins on the LCD component. When it
comes to using a third-party library like
LiquidCrystal_I2C , you'll make use of just 2 pins.

We'll be using the first method — this will help you

understand how the pins work. Now let's talk about
those pins.
What are the pins inForum
an Donate

LCD used for?

Learn to code — free 3,000-hour curriculum

The pins control functionalities like memory

management, data transfer, and power on an LCD.
Let's talk about them in detail:

The first pin from the left is the GND pin, which
is the LCD's ground pin. It is connected to GND
on the Arduino board. In some LCD modules, it
may be written as VSS.

The VCC is the power pin which is connected

to 5V on the Arduino board. In some LCD
modules, it may be written as VDD.

The V0 pin is used to adjust the contrast of the

LCD. It is connected to a potentiometer. Tuning
the potentiometer changes the contrast of the
data being displayed.

The RS (Register Select) pin can be used to

control the LCD's memory. It is usually
connected to a digital pin.

The RW (Read/Write) pin controls whether

data is written or read to the LCD. It is usually
connected to ground (GND) which sets the
LCD to write mode — this enables you to send
and display data with the LCD.
 Forum
The E (Enable) pin "enables" data transfer Donate
between thetomicrocontroller
Learn (incurriculum
code — free 3,000-hour our case, the
Uno board) and the LCD. It is usually connected
to a digital pin.

The D0 to D7 (can also be written as DB0 to

DB7) are the data pins. There are used to send
data to the LCD in bits. In most cases, the D4 to
D7 pins are used. The main difference is that
data is sent in 4-bits with the D0 to D3 pins,
while data is sent in 8-bits with the D4 to D7
pins. There are usually connected to digital
pins.

The LED pins are used to control the backlight

of the LCD. In some LCD modules, they may be
written as BLA and BLK, or A and K. The first
LED pin is connected to 5V using a resistor
while the second LED pin is connected to
ground (GND).

Example #1 – How to
Connect and Use an LCD
with Arduino
In the last section, we talked about the meaning of the
pins on an LCD. In this section, you'll see a practical
 Forumand write
example on how to connect them in a circuit, Donate
code to display
Learndata on
to code the3,000-hour
— free LCD. curriculum

We'll use the following components:

Arduino Uno.

16 x 2 LCD.

Potentiometer.

Jumper wires.

Resistors.

Breadboard.

Here's what the circuit diagram looks like:

In the circuit above, we made the following

connections from the LCD to the Uno board:
 Forum
The LCD's GND pin was connected to GND on Donate
the UnoLearn
board.
to code — free 3,000-hour curriculum

The LCD's VCC pin was connected to 5V on the

Uno board.

The V0 pin was connected to the

potentiometer.

The RS pin was connected to digital pin 4 on

the Uno board.

The RW pin was connected to GND on the Uno

board.

The LCD's D4 was connected to digital pin 6 on

the Uno board.

The LCD's D5 was connected to digital pin 7 on

the Uno board.

The LCD's D6 was connected to digital pin 8 on

the Uno board.

The LCD's D7 was connected to digital pin 9 on

the Uno board.

The first LED pin was connected to 5V.

The second LED pin was connected to GND.

For the potentiometer, one of the outer legs (either

the left or right) was connected to 5V, the other outer
leg was connected to GND. Then the middle leg of the
potentiometer was connected to the V0Forum
pin on the Donate
LCD. This will enable
Learn to codeyou to3,000-hour
— free controlcurriculum
the contrast of the
LCD.

Next, we'll write some code!

#include <LiquidCrystal.h>

LiquidCrystal lcd(4, 5, 6, 7, 8, 9);

void setup() {
lcd.begin(16, 2);
lcd.print("freeCodeCamp!");
}

void loop() {

In the code above, we first included/imported the

built-in LiquidCrystal library which can be used to
interact with an LCD using Arduino code: #include
<LiquidCrystal.h> .

We then initialized the lcd object with the required

pin numbers: LiquidCrystal lcd(4, 5, 6, 7, 8, 9) .
The first number denotes the RS pin. The second
number denotes the E pin. The last four numbers
denote the data pins (D4 to D7).
 Forum Donate
Next, we initialized the number of columns and rows
Learn to code — free 3,000-hour curriculum
using the lcd.begin() function: lcd.begin(16, 2) .
We have 16 columns and 2 rows.

The lcd.print function prints data to the LCD. If

you've made all the connections right, you should see
"freeCodeCamp" displayed on the LCD.

In the next examples, we'll work with user input and

sensor data, and also see other lcd functions.

Example #2 – How to
Display User Input with
LCD in Arduino
In this example, we'll accept input from the user using
the serial monitor, and display the input along with a
welcome message on the LCD screen.

We'll make use of the same circuit in the previous

example. Here's the code:

#include <LiquidCrystal.h>
LiquidCrystal lcd(4, 5, 6, 7, 8, 9);

String userInput;
 Forum Donate
void setup() {
Learn to code — free 3,000-hour curriculum
Serial.begin(9600);
lcd.begin(16, 2);

lcd.print("Input name");

lcd.setCursor(0, 1);
}

void loop() {
if (Serial.available() > 0) {

userInput = Serial.readString();
lcd.print("Welcome " + userInput);
}
}

In the code above, we created a string variable called

userInput which will be used to store the value of the
user's input.

We then initialized the serial monitor —

Serial.begin(9600);

Next, we set the rows and columns of the LCD using

the lcd.begin function.

Using the lcd.print function, we printed "Input

name" on the LCD screen.
 Forum
This was followed by the lcd.setCursor(0, 1) Donate
function which
Learnhas two
to code parameters
— free — 0 and 1. 0
3,000-hour curriculum

represents first column on the left while 1 represents

the second row. So the cursor will be set to the second
line of the LCD.

We set the cursor to be on the second line because we

already have some text ("input name") on the first line
so it would be more ideal in this case to print the
message to the user on the next line. I'll show you an
alternative way to do this after this example.

In the void loop() function, we used the

Serial.readString() function to read the value of
user's input and stored it in the userInput variable.

Lastly, we printed a welcome message and the user's

name in the LCD. This will be printed on the second
line because that's where we set the cursor to be.

Play around with the code and see what happens as

you adjust the parameters of the lcd.setCursor()
function. This will help you understand it better.

Example #2 Alternative
An alternative way to print the message to the user is
by using the same line where the initial message was
 Forum
displayed. We can clear whatever is written on the Donate
first row of Learn
the LCD and
to code display
— free a different
3,000-hour curriculumvalue.

Here's how:

#include <LiquidCrystal.h>
LiquidCrystal lcd(4, 5, 6, 7, 8, 9);

String userInput;

void setup() {
Serial.begin(9600);
lcd.begin(16, 2);

lcd.print("Input name");
}

void loop() {
if (Serial.available() > 0) {
lcd.clear();
userInput = Serial.readString();
lcd.print("Welcome " + userInput);
}
}

In this example, we used the lcd.clear() function to

clear the initial request message and display/print the
welcome message to the user. The rest of the logic is
the same.
So when you type in a name in the serialForum
monitor an Donate
hit
enter, the request message
Learn to code ("Input name")
— free 3,000-hour curriculumwill be

cleared while the welcome message will be displayed

with the name you inputted.

Example #3 – How to
Display Sensor Data with
LCD in Arduino
In this example, we'll display data from a sensor on the
LCD. We'll use the temperature sensor. The logic here
is to sense the temperature of a room and display the
varying values on the LCD.

Here are the components we'll use:

Arduino Uno.

16 x 2 LCD.

Light-Dependent Resistor (LDR).

Potentiometer.

Jumper wires.

Resistors.

Breadboard.
Here's the circuit diagram: Forum Donate
Learn to code — free 3,000-hour curriculum

The circuit diagram is almost the same as the ones in

the previous examples, except that we added an LDR
to measure the intensity of light. Using the LDR, we'll
read, store, and display the value of light intensity on
the LCD.

Here's the code:

#include <LiquidCrystal.h>
LiquidCrystal lcd(4, 5, 6, 7, 8, 9);

int ldrPin = A1;

int ldrValue;

void setup() {
pinMode(ldrPin, INPUT);
lcd.begin(16, 2);
}
 Forum Donate
void loop() {
ldrValueLearn to code — free 3,000-hour curriculum
= analogRead(ldrPin);

lcd.clear();
lcd.setCursor(0, 0);
lcd.print("LDR value:");

lcd.setCursor(0, 1);
lcd.print(ldrValue);

delay(1000);
}

Let's break down the code.

We started by including the built-in LiquidCrystal

library and initialized the respective pins for working
with the LCD (refer to the first example if you do not
understand how the connection and initialization
works).

We then created two variables: ldrPin which

denoted the analog pin connected to the LDR, and
ldrValue to store the readings from the LDR.

In void setup() , we configured the LDR as an input

pin and set the columns and rows of the LCD.
Next, we read the value of the LDR usingForum
the Donate
function
analogReadLearn to code and
— freestored that
3,000-hour value in the
curriculum

ldrValue variable.

Using the lcd.clear() function, we clear the display

after each reading. This helps in making the reading
appear more accurately. If you remove the function,
then some values will still be on display and make your
results appear inaccurately (I spent about thirty
minutes figuring this out 😂).

After that, we set the cursor on the first row and

column of the LCD: lcd.setCursor(0, 0) , and
displayed a message ("LDR value:").

Using the lcd.setCursor(0, 1) function, we moved

the cursor down to the second row, and used
lcd.print(ldrValue) to print/display the value of the
LDR on the LCD.

Lastly, we added a delay of 1000 milliseconds.

Now you can see the value of light intensity in your

environment displayed on the LCD.

You can use a flashlight to increase and decrease the

exposure of light on the LDR, and then observe the
values change on the LCD. Pretty cool! Forum Donate
Learn to code — free 3,000-hour curriculum

Conclusion
Congratulations! We've come to the end of this
handbook. You now have enough knowledge to take
on bigger projects.

And that should be your next goal — applying these

concepts to projects that aid you and the people
around you. There is no limit to what you can create.
You can start by watching a couple of videos to see the
type of projects people build, then you can come up
with yours.

This handbook covered the necessary parts of

Arduino (both hardware and software) that you'll
need as a beginner to kickstart your journey.

The best way to improve and retain what you've

learned is by practicing and building.

Happy tinkering!

Ihechikara Vincent Abba

 ihechikara.com Forum Donate
Learn to code — free 3,000-hour curriculum

If you read this far, thank the author to show them you
care. Say Thanks

Learn to code for free. freeCodeCamp's open source

curriculum has helped more than 40,000 people get
jobs as developers. Get started

freeCodeCamp is a donor-supported tax-exempt 501(c)(3) charity organization (United States

Federal Tax Identification Number: 82-0779546)

Our mission: to help people learn to code for free. We accomplish this by creating thousands of
videos, articles, and interactive coding lessons - all freely available to the public. We also have
thousands of freeCodeCamp study groups around the world.

Donations to freeCodeCamp go toward our education initiatives, and help pay for servers,
services, and staff.

You can make a tax-deductible donation here.

Trending Guides

JS isEmpty Equivalent Coalesce SQL

Submit a Form with JS Python join()

Add to List in Python JS POST Request

Grep Command in Linux JS Type Checking

String to Int in Java Read Python File

Add to Dict in Python SOLID Principles

Java For Loop Example Forum
Sort a List in Java Donate
Matplotlib Figure Size For Loops in Python
Learn to code — free 3,000-hour curriculum
Database Normalization JavaScript 2D Array

Nested Lists in Python SQL CONVERT Function

Rename Column in Pandas Create a File in Terminal

Delete a File in Python Clear Formatting in Excel

K-Nearest Neighbors Algo Accounting Num Format Excel

iferror Function in Excel Check if File Exists Python

Remove From String Python Iterate Over Dict in Python

Our Charity

About Alumni Network Open Source Shop Support Sponsors Academic Honesty

Code of Conduct Privacy Policy Terms of Service Copyright Policy