mEmlnc.

com

Arduino programming
The Ultimate Beginner's Guide to Learn Arduino Programming Step by
Step
 2020

1nd Edition

By John Bach

mEmlnc.com
"Programming isn't about what you know; it's about what you
can figure out.” - Chris Pine
This book will help you to develop working source code for the Arduino
microcontroller. In these pages, we will primarily concern ourselves with the
software aspect of physical computing—designing code to work with
physical objects that exhibit behavior or interactivity through software.
Starting with the basic context of the Arduino platform to getting up and
running with our first code, we will discuss the structure and syntax of
Arduino’s C-based programming language, looking at variables, control
structures, arrays, and memory. This book will then go into many of the
functions unique to Arduino development for controlling digital and analog
input and output, timing, randomness, writing functions, and using many of
the Arduino libraries for working with different kinds of hardware and
communication protocols. Arduino, like Processing before it, adopted the
idea of a code sketchbook. We will carry on this metaphor as we talk about
the process of sketching in code as an intuitive method for quickly testing out
new ideas in code. Most of this book is written around this idea of developing
programming skills through sketching. We will also provide some
suggestions for new projects and hardware, new languages to try out, and
ways to contribute back to the community. This book intentionally does not
dwell too long on electronics theory, circuit design, hacking, or other
specifically hardware-based practices, although we’ll revisit the hardware
side of things in our last chapter to provide a small foundation for physical
computing. This book in many ways picks up where the Arduino
Programming Notebook left off, with even more in-depth discussions about
the Arduino environment; simple, no-frills code samples; and clear, easy-to-
read schematics and illustrations.The Notebook, a little PDF booklet, was my
first experience writing about the Arduino and was never meant to be more
than a brief guide for my students when I first introduced a class of 15
college art and design majors to the Arduino in 2007. Best laid plans and all,
this little booklet has now been translated into Spanish, Russian, and Dutch
(that I know of), is hosted in so many different places that it is impossible to
keep track of, and it’s been used in workshops and classes around the world. I
haven't updated the Notebook over the last few years, and in all honesty I am
not entirely sure what to do with it now, so hopefully this new book will fill a
void and find a similar, widespread adoption that the little booklet has
enjoyed all these years.

Lcd.print("MOAML MOHMMED Translation");

Introduction 11
Arduino Coding Environment and basic tools 12
What language is Arduino? 12
Arduino IDE 12
Chapter One 16
Transactions in Arduino language 16
Arithmetic transactions in Arduino 16
Budget transactions in Arduino 16
Boolean transactions in Arduino 16
Index access transactions in Arduino
Binary number coefficients in Arduino
Compound transactions in Arduino
Chapter II
Data types
The String object in the Arduino
General structure
Returned values
Minions
Transactions
Arrays in Arduino
Create an array
Access to the matrix
Type bool in Arduino
byte in Arduino
Type char in Arduino
Type double in Arduino
Type float in Arduino
General structure
Type int in Arduino
Strings In Arduino
General structure
Termination character null
Long strings wrapping
Matrices of text strings
Type word in Arduino
The keyword void in Arduino
Chapter III
Constants and variables
Decimal system (base 10)
Binary System (Basis 2)
Notes and warnings
Constants in Arduino
Variable Scope & Qualifiers
The keyword const in Arduino
The field of variables in Arduino
The static keyword in Arduino
Examples
Keyword volatile in Arduino
Volatile or long volatile integers?
Chapter IV
Control structures
Keyword break in Arduino
Continue keyword in Arduino
Loop do ... while iterative in Arduino
Keyword else in Arduino
Goto keyword in arduino
Expression if conditional in Arduino
Notes and warnings
Keyword return in Arduino
Examples
Expression switch ... case in Arduino
Transactions
While iterative episode in Arduino
Chapter V
Functions
The digitalRead () function in the Arduino
digitalRead (pin)
The digitalWrite () function in the Arduino
The pinMode () function in the Arduino
Time functions in Arduino
The delay () function in the Arduino
Arduino delayMicroseconds () function
Arduino micros () function
Arduino millis () function
Mathematical Functions in Arduino
Handling and verifying typefaces in Arduino
Arduino conversion functions
Provincial control functions in Arduino
Chapter VI
Additional tools
The keyword programm in Arduino
Examples

Notes and warnings

Chapter VII Proteus 162
Chapter VIII Matrices and loops for and condition if to control LEDs 174
Introduction
Since the launch of the Arduino open-source platform, the brand has
established themselves at the center of an expansive open-source community.
The Arduino ecosystem is comprised of a diverse combination of hardware
and software. The versatility of Arduino and its simple interface makes it a
leading choice for a wide range of users around the world from hobbyists,
designers, and artists to product prototypes.
The Arduino board is connected to a computer via USB, where it connects
with the Arduino development environment (IDE). The user writes the
Arduino code in the IDE, then uploads it to the microcontroller which
executes the code, interacting with inputs and outputs such as sensors,
motors, and lights.

Both beginners and experts have access to a wealth of free resources and
materials to support them. Users can look up information on how to set up
their board or even how to code on Arduino. The open source behind
Arduino has made it particularly friendly to new and experienced users.
There are thousands of Arduino code examples available online. In this book,
We will explain all the basic principles that a novice programmer needs to
enter the genius world, Arduino
 Arduino Coding Environment and basic tools

What language is Arduino?

Arduino code is written in C++ with an addition of special methods
and functions, which we’ll mention later on. C++ is a human-
readable programming language. When you create a ‘sketch’ (the
name given to Arduino code files), it is processed and compiled to
machine language.

Arduino IDE
The Arduino Integrated Development Environment (IDE) is the
main text editing program used for Arduino programming. It is
where you’ll be typing up your code before uploading it to the
board you want to program. Arduino code is referred to as
sketches.

Arduino is an open source platform used to build electronic projects (ranging

from simple projects such as thermometers to complex projects such as
robots, 3D printers, and IoT applications). The main goal of creating the
Arduino platform is to provide a user-friendly platform to help people
without prior knowledge of electronics and programming. The Arduino
platform consists of two main sections: the hardware section and the software
section. The hardware section consists of an Arduino board and related
electronic components and other hardware components, while the software
section consists of the Arduino Development Environment (Arduino IDE),
which represents the host environment for writing the code in the Arduino
language and uploading it to the Arduino boards to control the hardware
section.

Arduino is just a set of C / C ++ functions, which are mainly derived from C

and C ++ and the Wiring and Processing frameworks and are open source.
The Arduino language is used to program Arduino boards of various types.
Arduino is distinct from the C-derived language, being an object-oriented
language, containing many classes and objects such as String and Stream. In
addition, Arduino is rich in a lot of libraries that provide more functionality
such as working with any piece or additional electronic element, modifying
data, etc. Arduino is not only required to be used with the Arduino IDE but
can also be used with third-party development environments such as Eclipse.
 Chapter One
Transactions in Arduino language
Arithmetic transactions in Arduino

Arithmetic Operators perform the four basic arithmetic operations (addition,

subtraction, multiplication and division) in addition to other operations such
as calculating the remainder of division and assigning values to variables.

Modulus%
Calculates the rest by dividing two numbers by each other.

Laboratories *
Calculates the product of multiplying two numbers together.

OPERATION +
Calculates the result of adding two numbers together.

-
Calculates the result of subtracting two numbers from one another.

Labs /
Calculates the result of dividing two numbers by one.

Parameter =
The attribution coefficient tells the controller to evaluate the expression or
value on the right side of the coefficient = whatever and store it in the
variable on the left side of that coefficient.
Budget transactions in Arduino

Comparison Operators perform a balancing process, as it is called, between

two values, two variables, a variable and a given value, and then return a
logical value that represents the state of one operator (greater, smaller, equal,
etc.) relative to the other.

Parameter! =
Balance two values or two variables and return the true value if they are not
equal.

Parameter <
Balance two values or two variables and return the true value if the
coefficient on the left side is completely smaller than the coefficient on the
right side.

Parameter <=
Balances two or two values and returns true if the coefficient on the left side
is smaller than or equal to the coefficient on the right side.

Parameter ==
Balance two or two variables and returns true if the coefficient on the left side
is equal to the coefficient on the right side.

Parameter>
Balance two values or two variables and return the true value if the
coefficient on the left side is exactly larger than the coefficient on the right
side.
Parameter> =
Balance two or two values and returns true if the coefficient on the left side
is greater than or equal to the coefficient on the right side.
Boolean transactions in Arduino

Boolean Operators perform Boolean operators (AND operation, OR

operation, or NOT operation) on values or logical expressions and return the
resulting Boolean value.

!
The logical reflects the value or logical expression that precedes it by
applying the NOT logical operation to it;

&&
Applies the AND logical operation to two logical values or expressions and
returns the resulting logical value

||
Applies the logical OR operation to two logical values or expressions and
returns the resulting logical value
Index access transactions in Arduino

Pointer Access Operators (Pointer Access Operators) are transactions that are
used with cursors to provide cursor access to and references to variable
memory addresses, and variables to access values contained in memory
addresses referenced by cursors.

&
It is used to provide a reference to the referencing memory address of a
variable. A reference is an important feature used with pointers.

*
It is used to provide access to a value stored in a specific memory address
(Dereferencing) of an indicator. Access to data stored in memory addresses is
an important feature used with pointers.
Binary number coefficients in Arduino

Bitwise Operators performs all logical operations and offsets on number bits
and binary values and returns the resulting value.

&
In C ++, the AND operation is performed on each of the two corresponding
bits of the given numbers independently and gives the resulting numerical
value.

>>
The bits to its left to the left displace a specified number of digits equal to the
value to the right.

<<
The bits to the left of it to the right displace a specified number of digits equal
to the value on the right.

^
In C ++, the XOR operation is performed on each of the two corresponding
bits of the given numbers independently and gives the resulting numerical
value.

|
In C ++, the OR operates on each of the two corresponding bits of the two
given numbers independently and gives the resulting numerical value.

~
In C ++, the NOT operation is performed on each of the given bits
independently - unlike the & & coefficient | - and gives the resulting
numerical value.
Compound transactions in Arduino

Compound Operators are frequently used to write codes in Arduino to zero,

fine-tune and invert certain bits in binary values and other important
processes that greatly simplify and simplify code writing.

Parameter = &
Usually used with a constant variable to zero a specific bit value (ie make a
value of 0 or LOW).

Modulus = *
It is a shorthand for multiplying the current value of one variable by a
constant or another variable and then storing the result in the same variable.

OPERATION ++
Increases the value of the variable used by 1.

Parameter = +
A shorthand is the process of combining the current value of a variable with a
constant or another variable and then storing the result in the same variable.

-
Decreases the value of the variable used by 1.

Modulus = -
A shorthand for a constant or another variable is subtracted from the current
value of a variable and the result is stored in the variable itself.
Modulus = /
A shorthand is a process of dividing the current value of one variable by a
constant or another variable and then storing the result in the same variable.

Modulus = ^
Usually used with a constant variable to invert (reverse) a specific bit value.

Parameter = |
It is usually used with a variable of constant to set a specific bit value (set to
1 or HIGH).
Chapter II
Data types
The String object in the Arduino

The String () function creates a copy of the String class. There are several
ways to create text strings of different types of data: call the String () function
with:

Static text string of characters within double quotation marks (i.e. an array of
characters), or
A single constant character within single quotation marks, or
Another copy of the String object, or
Integer constant or long constant number, or
A fixed integer or long fixed number using a specified base, or
Integer or long variable number, or
Integer or long number variable using a specified base, or
A decimal or a double decimal number using specified decimal places.

If you call the String () function with a number, it creates a text string
containing a representation of that number's numbers via ASCII characters.
The default basis used in this case is 10. The following example would be
given:

String thisString = String (13);

Text string "13". A different basis can be used such as:

String thisString = String (13, HEX);

You will give the text string "D" which is the hexadecimal representation of
the decimal value of 13. If you prefer binary, try this example:

String thisString = String (13, BIN);

Which will give the text string "1101" which is the binary representation of
the decimal value of 13.

General structure

String (val)
String (val, base)
String (val, decimalPlaces)
Transactions
val
The variable or value to be formatted as a text string. The allowed data type
are: text string, typeface, byte, integer, pointless integer, long pointless
number, decimal number, and multiplier decimal.

base
Optional coefficient determines the basis of the numerical system in which
the numerical value will be formatted. The default value is: DEC.

decimalPlaces
Restricts the number of decimal places (numbers after the comma) to the
decimal or multiple of the decimal.
Returned values
A copy of the String class containing the value val is returned.

Examples
All of the following are valid examples of using the String () function:
String stringOne = "Hello String"; // Use a fixed text string
String stringOne = String ('a'); // Converts a fixed typeface to a text string
String stringTwo = String ("This is a string"); // String Converts a static text
string to an object of type
String stringOne = String (stringTwo + "with more"); // Combine two text
strings together
String stringOne = String (13); // Use a constant integer
String stringOne = String (analogRead (0), DEC); // Using an integer
specifying the basis used
String stringOne = String (45, HEX); // "Use integer with base set to" hex
String stringOne = String (255, BIN); // "Use an integer with the baseline set
to" binary
String stringOne = String (millis (), DEC); // Use a long number and specify
the basis used
String stringOne = String (5.698, 3); // Use a decimal number and specify the
number of decimal places

Minions
charAt ()
The function fetches a character with a specific index from the text string that
is called with it.
compareTo ()
The function balances two text strings and determines which is greater than
the other or if they are equal.

concat ()
The function adds the parameter passed to it to the text string that is called
with it.

c_str ()
The function converts the content of the text string with which it is called to
the ideal text string style in C (the text string ending in null).

endsWith ()
The function verifies whether the text string called with it ends with the same
characters that were passed to it.

equals ()
The function verifies if the text string you are calling is equal to the text
string you passed to.

equalsIgnoreCase ()
The function verifies if the string you are calling is equal to the string you
passed to, not taking into account the case.

getBytes ()
The function fetches a specified number of bytes of the text string that is
called with it and places it in a specific repository.

indexOf ()
The child index returns the first appearance of a particular character or text
string within the text string that is called with it.

lastIndexOf ()
The child index returns the last appearance of a particular character or text
string within the text string that was called with it.

length ()
The function returns the number of characters of the string that is called with
it.

remove ()
The function deletes a specified number of characters of the text string with
which it is called.

replace ()
The child substitutes a typeface or substring where a specific typeface or
substring exists in the string that is called with it.

reserve ()
The slave reserves part of the memory and allocates it to manipulate and
modify the text string that is called with it.

setCharAt ()
The function assigns the value of a character that is positioned in the text
string with which it is called.

startsWith ()
The function verifies whether the text string called with it begins with the
same characters that were passed to it.

substring ()
The child fetches a specific part of the text string that is called with it.

toCharArray ()
The function converts the whole or part of the text string that is called with it
into a string of characters.

toInt ()
The function converts the text string with which it is called into an integer.

toFloat ()
The function converts the text string with which it is called to a decimal.

toLowerCase ()
The function converts all the characters of the text string with which it is
called into lower-case letters.

toUpperCase ()
The function converts all the characters of the text string with which it is
called to upper-case.
trim ()
The function removes all white spaces from the beginning and end of the text
string called with it.

Transactions
[]
The operator provides access to and returns a specific character of the string
used.

+
The operator combines (merges) two text strings together into one new text
string and then returns them.

=+
The operand adds any type of data to the end of a particular text string.

==
The coefficient verifies that two text strings are equal to each other.

<
The operand checks if the text string to the left is exactly larger than the text
string to the right.

=<
The operand checks if the text string to the left is greater than or equal to the
text string to the right.
>
The operand checks if the text string on the left is smaller than the text string
on the right.

=>
The operand checks if the text string to the left is less than or equal to the text
string to the right.

=!
The parameter checks if the text string on the left is different from the text
string to the right.
Arrays in Arduino

An array is a set of variables placed in a single container that can be accessed

by their index number. Matrices in C, on which Ardonyo is based, can be a
bit complicated, but using them in the simplest form is easy.

Create an array

There are several ways to create an array:

int myInts [6];

int myPins [] = {2, 4, 8, 3, 6};
int mySensVals [6] = {2, 4, -8, 3, 2};
char message [6] = "hello";

You can declare an array without initializing it and placing values in it as in

myInts. An array can be declared without explicitly specifying its size, such
as myInts; in this case, the bank will count the elements and give the matrix
an appropriate size.
However, you can configure an array and specify its size as in the case of the
mySensVals array. Note that when declaring an array of characters, you need
to increase the size of the array to the size required to accommodate only one
additional element, the null, which is located at the end of the characters; see,
for example, the size of the message array in the previous example and the
number of characters stored in it.

Access to the matrix

The indexing of elements in the array begins with a value of 0; the index of
element 2 in the mySensVals matrix - in the previous example - is 0, the
index of element 4 (second element) is 1, and so on. This also means that the
index of the last element of a 10-element array is 9, not 10! Here's an
example:

int myArray [10] = {9,3,2,4,3,2,7,8,9,11};

// The value 11 contains the myArray [9] element
// It works outside the array and has myArray [10]
// Returns a random value from memory

For this reason, you should be careful not to make this error when accessing
any element of an array. Accessing an element that falls after the last element
(indexed greater than the size of the array with a value of 1), or generally
outside the array, leads to reading from a portion of memory that is intended
for other purposes. Reading this part does not return valid values or data.
Conversely, writing on a piece of memory outside the reserved portion of an
array, when assigning a value to one of its elements, is bad and more
dangerous than reading that part, as it can lead to disastrous and unexpected
results such as program crashes and downtime. This error may be difficult to
track and refine.
The C language expense does not verify access to arrays defined in the
program, although an access exceeds the limits of one, unlike BASIC or
JAVA, to verify this.

Assign a value to an array element

Any value can be assigned to an array element by using the attribution

operator = and the index of the element in question
Assign the value to it as follows:

mySensVals [0] = 10;

Bring value from the matrix

The value of any array element can be fetched by the index of that element as
follows:

x = mySensVals [4];

Arrays and loops

Arrays are frequently used within loops to modify or fetch the values of their
elements. The loop counter is used as the index of each element of the array.
For example, to print all array elements on a serial interface, you can use
something similar to the following example:

int i;
for (i = 0; i <5, i = i + 1) {
Serial.println (myPins [i]);
}
Type bool in Arduino

The declared bool variable stores one of the following two logical values:
true, or false, by reserving only one byte of memory.

General structure
bool var = val;
Var represents the name of the variable to declare, and val is the value to
assign to this variable, which is either true or false.
Examples
The following example illustrates how to use the bool type to make the light
attached to the leg 5 flash each time the cutter connected to the leg 13 is
pressed:
int LEDpin = 5; // LED light connected to leg 5
int switchPin = 13; // An instantaneous cutter connected to the 13th leg, and
the other leg connected to the ground

bool running = false;

void setup ()
{
pinMode (LEDpin, OUTPUT);
pinMode (switchPin, INPUT);
digitalWrite (switchPin, HIGH); // Activating the internal lifting resistance
}

void loop ()
{
if (digitalRead (switchPin) == LOW)
{// Was the cutter pressed? Patches resistance keeps voltage always high
delay (100); // Delay in order to neglect the cutter bounce
 running =! running; // Switch the value of the variable
digitalWrite (LEDpin, running); // Indicating the state of the variable through light
}
}
byte in Arduino

Byte stores an unsigned 8-bit number, i.e. from 0 to 255.

General structure

byte var_name;
byte var_name = Number; // 0 - 255

Examples
Example of defining a byte variable:

byte myNumber = 125;

byte result = myNuber / 5;

Note that the numbers after the comma in the second case will be neglected if
the division (or any calculation) result in a decimal.
Type char in Arduino

The char type reserves one byte of memory and stores a typeface value.
Characters are written in single quotes like 'A' (for several characters
[[[Arduino / string | text string]]], use an even quotation mark like 'ABC').

Numbers are stored in the bytes reserved for the char type representing the
value of the corresponding character. These numbers are referred to as
coding, and the coding used here is ASCII coding. Go to the ASCII
Documentation Documentation to see all the characters and the
corresponding numerical value for each. This means that it is possible to
perform some calculations on the characters in which the ASCII value is used
(such as carrying out the operation A '+ 1' which will give the value 66
corresponding to the letter 'B', since the numerical value of the letter 'A' in the
ASCII symbol is 65). Take a look at the Serial.println () function
documentation for more information on how to switch characters and their
numerical value.

Char is a type with a signal; this means that the numerical values it can take
ranges between 128 and 127. If you want one byte without a signal to store
data in it, use the type byte.

General structure

cahr var = 'character';

char var = Number;

Var represents the name of the variable to declare, and the character
represents the character to be attributed to that variable. The corresponding
character number can be used in ASCII encoding instead of the same
character.

Examples

Example of defining a type char:

char myChar = 'A';
char myChar = 65; // Both represent the same typeface
Type double in Arduino

Double is a decimal number with double precision. On Arduino and other

ATMEGA-based boards, this type reserves only 4 bytes (32 bits) of memory.
This means that the double type in these panels exhibits the behavior of the
float type itself without any difference and without any increase in accuracy.

In Due panels, the size of the double type is 8 bytes (64 bits), which is twice
the float.

General structure

double var;
double var = val;

Var represents the name of the variable to declare, and val represents the
decimal value to assign to this variable.

Examples
An example of defining a double variable:

double myNumber = 12.123456789;

double result = myNumber / 2;

Notes and warnings

Users who bring codes that contain double type variables from other sources
must try and test the code to ensure that the desired precision does not differ
due to the different boards that will be implemented on it (especially boards
that rely on ATmega controllers).
Type float in Arduino

The type float is used with decimal numbers, which are fractional numbers
that are used as a decimal separator. Decimal numbers are often used to
approximate similar continuous values because they have greater accuracy
than integers. Decimal numbers can be large with the number 38.028235E +
38 and small with the number 38-4282835E +. The float type reserves four
bytes (32 bits) of memory to store a float.

Float decimal numbers have a small precision of 6-7 decimal places after the
comma. In Arduino Uno and other ATMEGA control boards, there is no
higher resolution than this by using double (double float), as the size of this
type is exactly the same as float. In Due panels, the double type provides
double precision.

Doing mathematical operations on decimal numbers is much slower than

performing the same operations on integers, so decimal numbers should be
avoided if the timing is critical for some functions and the iterative function
is required to repeat the operations at the fastest speed and the shortest
possible time. Programmers usually avoid performing arithmetic operations
on decimal numbers and convert and manipulate these operations to perform
on integers only in order to increase the speed of the program.

If your program performs mathematical operations on decimal numbers, then

you must add to all the fixed numbers used in these operations decimal places
after the comma if they do not have them (such as 12.0); if you do not (i.e.
you use the number 12 only), then these numbers will be treated as Integers.
See the decimal point fixed number page for more information.

General structure
float var;
float var = val;

Var represents the name of the variable to declare, and val represents the
decimal value to assign to this variable.

Examples
An example of defining a float variable and performing a calculation on it:

float myfloat;
float sensorCalbrate = 1.117;

int x;
int y;
float z;

x = 1;
y = x / 2; // the value 0, because it cannot store the decimal parts y will
contain the variable
z = (float) x / 2.0; // (the value 0.5) pay attention to the number 2.0 and do
not use 2 only z will contain the variable
Type int in Arduino

Whole numbers are the primary data type used to store numbers.

On Arduino Uno boards (and ATMega based boards), the int type reserves a
16-bit (2-byte) size of memory in which numbers between 32768- (the
smallest value equal to 15 ^ 2) can be stored and 32767 (the largest and equal
value 1 - 15 ^ 2). In Arduino boards and SAMD-based boards (such as
MKR1000 and Zero), the type reserves a 32-bit (4-byte) amount of memory
to store numbers from 2,147,483,648- (31 ^ 2-) to 2,147,483,647 (1-31) ^ 2).

This type stores negative numbers with a technique called "Two's

complement". The most important upper bit (MSB) determines whether a
number is negative or positive, and it is often called a “sign bit”. When its
value is 1, the value of all remaining bits is reversed and added 1.

Arduino has the task of dealing with negative numbers, so the calculations
are performed on them transparently and in the expected way. However, there
may be some complexity in dealing with the displacement coefficient <<.

General structure

int var = val;

Var represents the name of the variable to declare, and val represents the
correct numerical value to be assigned to that variable.

Examples
The following example will create a variable called countUp and assign an
initial value to it; this variable will be used as an ascending counter, as its
value will be increased during the loop and will appear on the serial
communication interface:
int countUp = 0; // Declare a variable with integers

void setup () {
Serial.begin (9600); // Configure and start the serial port
}

void loop () {
countUp ++; // countUp Add the value 1 to the variable
Serial.println (countUp); // Print the value of the current variable on the serial port
delay (1000);
}

Notes and warnings

If the signal variables exceed the maximum or minimum value of the type in
which they are defined, then they will have reached an "overflow" state, and
their value cannot be predicted at that time. Consequently, care must be taken
to make a variable reach the condition of rash (unless this is desirable). One
of the indicators of the variable's arrival to the state of rash is the transfer of
the variable from its maximum value to its minimum value or vice versa.
Note that we said "one of the indicators" and not the only evidence that a rash
occurred, so be careful. If you define a variable and do not intend to use it to
store a negative value in it, then the unsigned int of this type, which is an
unsigned int, should be used to reduce the possibility of reaching the
overflow.
Strings In Arduino

Strings can be represented in two ways. Either the text strings are used as one
of the data types in Arduino which became part of the kernel starting in
version 0019, or a text string can be created from an array of characters with
the null character in the end; the second method will be explained on this
page, as the first method is explained in detail in documentation The string
object provides many functions and tools for manipulating text strings but at
the expense of memory.

General structure
All of the following examples are valid strings for declarations:

char Str1 [15];

char Str2 [8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'};
char Str3 [8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\ 0'};
char Str4 [] = "arduino";
char Str5 [8] = "arduino";
char Str6 [15] = "arduino";

There are several possibilities available for declaring strings:

Declaring a matrix without formatting as in Matrix Str1.
Declaring a matrix of characters (increasing the size to accommodate an
additional character), and the compiler will automatically add the required
null as the Str2.
This case is just like the previous case except for explicitly adding null to the
array like Str3.
Configure the array with a fixed text string given in quotation marks; when
decoding the code the array will choose an appropriate size for the array that
fits the fixed text string with a null terminator. Look at the Str4 matrix for this
case.
Initializes the array and explicitly specifies it, such as Str5.
Configure the matrix with an oversize option to provide future text string
capability; see Str6 for example.

Termination character null

Generally, strings terminate with null (ASCII 0). This allows functions (such
as the Serial.print () function) to know the end of a text string when it is read
or fetched from memory. If the terminate character is not present, the
function will complete reading or fetching successive bytes in memory that
may not be part of the text string itself.

This means that any text string must have additional space for an extra
character in addition to the content that you want to store in the string. This is
the reason why Str2 and Str5 need a size of 8, even though the phrase
“arduino” is only 7, because in the last available position the typeface will be
added null automatically. For Str4, its size will be set to 8 characters
automatically, taking the termination character into account. In matrix Str3,
we added the null null of the expression ('0 \') manually.

Note that it is possible that there is a text string that does not have a terminate
character (such as setting Str2 to 7 instead of 8). This will malfunction in
most of the functions dealing with strings, so you should avoid doing this
inadvertently. If you notice that the behavior of the program has become
somewhat strange (especially when dealing with characters and not with
strings), then the termination character is likely to be the cause of the
problem.

Single and double quotation marks

Strings are always defined inside double quotation marks like "ABC", and
characters are always defined inside single quotes like 'A'.

Long strings wrapping

Long strings can wrap and move to the following line as:
char myString [] = "This is the first line"
"And this second line"
" And so on";

Matrices of text strings

It is often appropriate when dealing with a large amount of text, such as
working on a project with an LCD screen, creating an array of text strings.
Since the strings are matrices themselves, in this case we will use a two-
dimensional matrix.

In the following example, the presence of the parameter * after defining the
type of data that is char as "* char" indicates that the matrix to be declared is
an array of pointers. Really, all arrays are pointers, so using this parameter *
in this way is important to create an array of arrays. The indicators in C are a
little complicated and not understood by many novice programmers, but it is
enough to understand the indicators only superficially to deal with them in
our case.

Examples
An example of defining an array by using a parameter * and printing the
contents of this array on the serial interface:
char * myStrings [] = {"This is string 1", "This is string 2", "This is string 3",
"This is string 4", "This is string 5", "This is string 6"};

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

void loop () {
for (int i = 0; i <6; i ++) {
Serial.println (myStrings [i]);
delay (500);
}
}
Type word in Arduino

Word type variables store a non-signal number of 16 bits (2 bytes), with a

value ranging from 0 to 65,535 max. This type is similar to the unsigned int
type.

General structure

word var = val;

Var represents the name of the variable to declare, and val represents the
value to be attributed to that variable.

Examples

Example of defining a variable of type word and assigning a value to it:

word w = 10000;
The keyword void in Arduino

The keyword void is used with functions defined by the programmer in the
code to indicate that this function is not expected to return any data to
whoever called it after its execution. Based on this definition, the return
keyword is not assumed to be used within the function declared with the
keyword void.

General structure

void function ()
{
// The code block that the code will execute
}

Examples

The following code explains how to use void with the setup () function and
loop () to indicate that they will not return anything after their
implementation is complete:
// But "loop" and "setup" will not be executed for all tasks within the two functions
// Neither of them returns any data back to the higher program that called them

void setup ()
{
// ...
}
void loop ()
{
// ...
}
 Chapter III
Constants and variables

Fixed integers in Arduino

Fixed integers are numbers used directly in the code such as 123. By default,
these numbers are treated as integers but can be converted to other types of
numbers using a modifiers such as U or L.

Integers are treated as integers based on the number 10 always (ie represented
by decimal by default). However, other formulas can be used to write
numbers, since the basis of the number will vary.
Decimal system (base 10)
This system is the common counting system among humans that they always
use in calculations. Numbers written in the code that are not preceded by any
coordinator (prefix determining the number formula) are considered as
numbers written in decimal (base 10).

n = 101; // ((1 * 10 ^ 2) + (0 * 10 ^ 1) + 1) == 101

Binary System (Basis 2)
The values in this system are represented by numbers 0 and 1 only.

n = B101; // ((1 * 2 ^ 2) + (0 * 2 ^ 1) + 1 * 2 ^ 0) == 5 in decimal

The binary formula is only valid for byte (8-bit) values; between 0 (B0) and
255 (B11111111). If you want to use the binary formula with larger values -
such as with integers (16 bits) - you can do this by performing a simple two-
step process as follows:
myInt = (B11001100 * 256) + B10101010; // is the upper byte value
B11001100

Eight (Basis 8)
The numbers used to represent the values in this system are from 0 to 7. The
values to be written and represented in this system begin with the
coordinator 0 (zero).
n = 0101; // ((1 * 8 ^ 2) + (0 * 8 ^ 1) + 1) == 65 in decimal
A logical error that is difficult to find in the code is likely to result from an
unintentional zero constant; this leads the interpreter to interpret this constant
as a value of eight during code discharge.

Hexadecimal system (base 16)

The numbers and characters used to represent the values in this system are 0
to 9 and A to F. In fact, the decimal value of the letter A is 10, the letter B is
11, and so on until the letter F is 15. The values to be represented and written
in the hexadecimal system With prefix 0x. Note that the letters A-F can be
used in uppercase or lower case (a-f).
n = 0x101; // ((1 * 16 ^ 2) + (0 * 16 ^ 1) + 1) == 257 in decimal
Notes and warnings

The U and L switches

By default, a constant integer is treated as a type of integer that has a limited

size that is insufficient in some cases. To change this type to another type of
data, you can use one of the U or L switches as follows:

'u' or 'U': This switch is used at the end of the numerical constant to convert it
to an unsigned type such as 33u.
'l' or 'L': This switch is used at the end of the numerical constant to convert it
to a 'long number' type such as 100000L.
'ul' or 'UL': The two switches are used together at the end of the numerical
constant to convert it to a 'long number without signal' type such as 32767ul.
Constants in Arduino

Constants are predefined expressions in the Arduino language. Used to make

it easier for programmers to work as they write code, as well as to make the
code more readable. Constants are grouped by function.

Defining logical levels (logical constants)

In Arduino, there are two constants used to represent truth and falsity: true
and false.

The constant is false

The logical false value is an error value and is defined as numerically zero
(0).

The constant is true

A true Boolean is a true value and is defined as one (1) numerically. In fact,
true represents a wider range of numeric values than just 1. Any non-zero
value is logically referred to as true. Accordingly, values 1, 2, and 200 all
logically indicate true.

Be aware that true and false are lowercase, unlike other constants such as
HIGH, LOW, INPUT, etc.

Definition of the state of the legs (voltage level)

When reading or writing the value of digital legs, we find that we are dealing
with two values that are not third; one of the digital legs can be taken or set
to HIGH or LOW.
Hard HIGH
The meaning of the fixed HIGH value, when dealing with the legs of the
Arduino board, varies depending on the position of the man; that is, the man
is an INPUT or an OUTPUT. If the man is set to a man who has entered by
passing the INPUT value to the pinMode () function and is read using the
digitalRead () function, the ATmega controller will report the HIGH value if:

The voltage applied to the leg is greater than 3.0V on panels with a voltage of
5V, or
The voltage applied to the leg is greater than 2.0V in 3.3V panels.
The man can also be set to an input man by passing the INPUT constant to
the pinMode () function and then typing the HIGH value on it using the
digitalWrite () function. This will activate the internal lifting resistance
associated with that man. Activating this resistance will raise the man's effort
to HIGH unless it is reduced to LOW by connecting it to an external circuit.
This is very similar to what the INPUT_PULLUP constant does when passed
to the pinMode () function, which we will address later.

When a man is set to an output man by passing the OUTPUT constant to the
pinMode () function, and then typing the HIGH value on it using the
digitalWrite () function, that man's effort will be:

5 volts in 5V, or
3.3V in 3.3V panels.
When a man is in this state, then a current can be drawn to light a LED light,
for example by connecting one of its poles to it and connecting the other pole
with resistance on the sequence to the ground pole.

Hard LOW
The meaning of the fixed LOW value also varies depending on the position
of the man; If the man is set to an input man by passing the INPUT value to
the pinMode () function and is read using the digitalRead () function, the
ATmega controller will report the LOW value if:

The voltage applied to the leg is smaller than 1.5V in panels with a voltage of
5V, or
The voltage applied to the leg is smaller than approximately 1.0V in 3.3V
panels.
When a man's position is set to an output man by passing the OUTPUT
constant to the pinMode () function, and then typing the LOW value on it
using the digitalWrite () function, that man's voltage is 0 volts (in both 5V
and 3.3V panels). When the man is in this situation, a current can be
discharged, such as one light pole connected to it and the other pole with
resistance on the sequence with a 5V + (or 3.3V +) pole to light it.

Definition of legs position (input or output)

Digital legs can be used as input legs or output legs by using one of the
INPUT, INPUT_PULLUP, or OUTPUT constants with the pinMode ()
function. When a man is so prepared, her electrical behavior is completely
changed internally.

Hard INPUT
The legs of the Arduino board set as input legs using the INPUT constant
with the pinMode () function are said to be in high-impedance state. The legs
set to the INPUT legs make the burdens on the circuit you are examining
very small, equivalent to a 100-ohm sequence resistance in front of the man.
This makes the legs very useful in reading sensor values.

If one of the legs is set as an input man and used to read a switch, the man's
condition will be “floating” when the cutter is open; this will produce
unexpected results. To ensure that the leg condition is read correctly when the
cutter is open, use an external pull-up or pull-down resistance with this leg.
The goal of connecting the resistance to this man is to adjust its effort to a
known state when the cutter is open. A resistance of 10 k ‫ أوم‬is usually used,
which is small enough to prevent the input leg from floating, and large
enough to not pull a large amount of current when the cutter is closed. See
this tutorial for more information.

If an external pull-down resistor is used, the input leg voltage will be low
when the cutter is opened, and HIGH when the cutter is closed.

If an external pull-up resistor is used, the input leg voltage will be HIGH
when the cutter is opened, and LOW when the cutter is closed.

The INPUT_PULLUP constant

The ATmega controller in the Arduino board has internal lifting resistance
connected to each leg of the input and output legs that can be controlled. If
you prefer to use this resistance instead of adding an external lifting
resistance, you can do so by passing the INPUT_PULLUP constant to the
pinMode () function when configuring the leg. Check out this tutorial, which
contains a practical example of what we have mentioned.

WARNING: Legs set as input legs using INPUT or INPUT_PULLUP can be

damaged or destroyed if they are connected with voltage below ground
voltage (negative voltage) or greater than positive voltage (5V or 3.3V).

Hard OUTPUT
It is said that the legs of the Arduino board set as the output legs by using the
OUTPUT constant with the pinMode () function are in a high-impedance
state. This means that they can provide enough current to other devices and
circuits connected to them. Any man with ATmega legs can give or discharge
other devices and circuits up to 40 mA. Exceeding this value of current
damages the controller, so resistors or similar electronic elements must be
used to determine current when connecting electronic parts that require large
amounts of current such as motors.

WARNING: Legs set as output legs using OUTPUT can be damaged or

vandalized if connected with ground voltage or positive voltage of the current
source directly used.

Define embedded elements in the panel

Fixed LED_BUILTIN
Most Arduino boards have LED light integrated into the board and connected
to one leg with resistance on the sequence. The constant LED_BUILTIN
represents the number of the man connected to this panel light. This man is
the 13th man in most Arduino paintings that have a built-in light on them.
Variable Scope & Qualifiers

The keyword const in Arduino

The keyword const is an abbreviation of the word constant, which is

constrained by the variables that are used with it. This means that a variable
can be used as a representative of variables of the same type, except for the
inability to change the value that was assigned to it when it was created. You
will encounter an error from the banker if you try to assign a value to a
variable with which the keyword const is used.

Constants defined using the const keyword comply with variable scoping
rules that set the rest of the variables. Taking the risks of define # into
consideration, this makes the keyword const the best way to define constants,
and preferably use them instead of define #.

General structure

const dataType var = val;

The dataType represents the type of variable to be defined, var the name of
the variable, and val the value to be assigned to this constant variable. Note
that once val is assigned to a variable, it can no longer be changed, and the
variable will be read-only.
Examples

Use the word const to define the constant π used in mathematical operations:
const float pi = 3.14;
float x;
// ....

x = pi * 2; // Constants are frequently used in mathematical operations

pi = 7; // This will generate an error, as a constant variable cannot be overwritten

Notes and warnings

Expression define # or keyword const?
You can use either the keyword const or the #define to create numeric or text
constants. For arrays, you only need to use const with them. In general, the
use of the keyword const is preferable to the use of the define # expression.

The field of variables in Arduino

Variables in the C language, from which Arduino is derived, have a property

called scope that determines the scope of use of those variables and who can
access them. This is different from recent versions of languages such as
BASIC where the variable is always global.

General variables can be seen by all functions in the program. On the other
hand, local variables are only visible in the function within which they are
defined and not available to other functions. In the IDE environment, any
variable declared outside a function (such as setup (), loop (), etc.) is a global
variable.

When a program becomes larger and more complex, local variables are more
useful than general ones to ensure that only one function reaches the
variables defined within them. This prevents errors from one function from
modifying variables that another function inadvertently uses.

It is useful to declare variables and assign them value within iterative loops
such as for. This prevents anything outside the loop from accessing and
modifying this variable.

Examples
int gPWMval; // Any function can see and access this variable

void setup ()
{
// ...
}

void loop ()
{
int i; // loop is only visible within the variable "i" loop
float f; // Only the loop is also visible within the variable "f" loop
// ...

for (int j = 0; j <100; j ++) {

// only for available within the variable j
}

}
The static keyword in Arduino

The static keyword is used when creating visual variables for only one
function in order to preserve its content after the execution of that invoked
function and until the next call to it, unlike the local variables that are created
and destroyed each time the function is called.

The static variables declared within the function will be created and
initialized with the static keyword only the first time that function is called.

General structure

static dataType var = val;

The dataType represents the type of variable to be defined, var the name of
the variable, and val the value to be assigned to this static variable. Be aware
that once the var variable is created when the function is first called, it will
not be destroyed when the function is executed and the value stored within it
will be preserved until the next call to the function.
Examples

The following program generates random steps that are limited to a specific
domain and also limits the size of the steps through the stepsize variable
passed to the randomWalk () function:
/ * RandomWalk
* Paul Badger 2007
* RandomWalk wanders up and down randomly between two
* Endpoints. The maximum move in one loop is governed by
* the parameter "stepsize".
* A static variable is moved up and down a random amount.
* This technique is also known as "pink noise" and "drunken walk".

#define randomWalkLowRange -20

#define randomWalkHighRange 20
int stepsize;

int thisTime;
int total;

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

void loop ()
{// randomWalk test function
stepsize = 5;
thisTime = randomWalk (stepsize);
Serial.println (thisTime);
delay (10);
}

int randomWalk (int moveSize) {

static int place; // is defined as static so it stores values randomWalk is
a variable that stores a value in the function
// Between function calls with this variable remaining local
and only accessed by this function

place = place + (random (-moveSize, moveSize + 1));

if (place <randomWalkLowRange) {// Check the upper and lower limits

place = randomWalkLowRange + (randomWalkLowRange - place); //
Reverses the number in the opposite direction to the positive direction
}
else if (place> randomWalkHighRange) {
place = randomWalkHighRange - (place - randomWalkHighRange); //
Reverses the number in the opposite direction to the negative direction
 }

return place;
}

Keyword volatile in Arduino

The keyword volatile is categorized under 'variable qualifier', and is usually

used before the variable type when it is defined to modify the way the banker
and the subsequent program treat this variable.

The key word volatile, when used to define a variable, is a directive for the
banker itself. The banker is a program that converts the C / C ++ code into an
executable code that the hardware understands; this code contains actual
commands for the controller on the Arduino board telling him what to do.

What the volatile keyword does with the variable is to direct the banker to
load the variable from RAM and not from the flash memory records where all
program variables are stored. In some cases, the value stored in the recorders
for a variable may be inaccurate.

The variable must be defined with the keyword volatile whenever its value
can be changed by anything beyond the control of the code fragment within
which this variable appears (such as simultaneously executing a string). In
Arduino, the only place where this is likely to happen is the district-related
code fragments called the ISR programs.
Volatile or long volatile integers?

If you use the word volatile with a variable that is larger than one byte (2
bytes as an integer, 4 bytes as a long number, etc.), the controller will not be
able to read it in one step because the controller architecture is often 8 bits
(make sure the architecture is Control panel). This means that while the first
eight bits of the variable are read in a part of the code (such as the loop), the
interrupt may have already changed the other eight bits (if the variable size is
16 bits). This will get a random value for the variable.

The solution to this problem is to disable interrupts while reading variable

values, so that the values of the variable bits do not change as they are read.
There are several ways to do this:

Use the noInterrupts () function to disable interrupts, or

The use of the block ATOMIC_BLOCK, where atomic operations are single
operations performed by the controller (MCU) and represents the smallest
possible unit.

Examples

Switch the state of the connected foot with LED light when an interrupt
occurs on foot 2:

int pin = 13;

volatile byte state = LOW;

void setup ()
{
 pinMode (pin, OUTPUT);
attachInterrupt (digitalPinToInterrupt (2), blink, CHANGE);
}

void loop ()
{
digitalWrite (pin, state);
}

void blink ()
{
state =! state;
}
Chapter IV
Control structures
Keyword break in Arduino

The break keyword is used to get out of loops for, while, or do ... while
iterative, bypassing the next code and the specified loop conditions and
exiting them. Also used to exit the programmatic switch ... case expression.

General structure

break;

Examples

In the following code, the controller exits the for loop when the measured
sensor value exceeds a certain threshold:
for (x = 0; x <255; x ++)
{
analogWrite (PWMpin, x);
sens = analogRead (sensorPin);
if (sens> threshold) {// Ensure that the measured value does not exceed
the threshold
x = 0;
break;
}
delay (50);
}
Continue keyword in Arduino

The continue key passes the next code in the iteration loop (such as for,
while, or do ... while iterations) to check the conditional expression of that
loop and then the loop loop is resumed normally. Making this statement is
similar to making a jump in the loop to skip execution when a certain
condition is met.

General structure

continue;

Examples
In the following code, the value 0 to 255 will be written on the foot PWMpin
with skipping the values in the range 41 to 119:

for (x = 0; x <= 255; x ++)

{
if (x> 40 && x <120) {// Causes a jump in values
continue;
}

analogWrite (PWMpin, x);

delay (50);
}
Loop do ... while iterative in Arduino

The iterative do ... while loop works the same as the while loop except that
the condition is checked at the end of the loop, not at the beginning. This
means that the loop will be executed at least once.

General structure

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

A condition is a logical expression and will be evaluated as either true or

false.

Examples

An example of using the do ... while loop to read a value from a sensor and
waiting for it to reach a certain limit:
do
{
delay (50); // Wait for the sensor value to stabilize
x = readSensors (); // Read the value of the sensor
} while (x <100);
Keyword else in Arduino

The conditional if ... else expression allows more control over the sequence
of validating several specific conditions when executing the code rather than
verifying a single condition when using the if expression. The else statement
(if any) will be executed if the condition given in the if statement is not met.
You can also use the else statement with the if statement as else if to add
another condition to verify, so that several consecutive checks can be
performed at the same time.

If there are several conditions to be verified, it will be met from the first
condition and then from the next condition if it returns false and so on until
one of the conditions is met (ie returns true). When the condition is met, the
associated block will be executed and the program will skip the entire if / else
structure to the next line. If no condition is met, the default else block will be
executed if it eventually occurs.

Note that the else if block may be used with or without the else block at the
end and vice versa. The number of times the use of the else if block in any
conditional expression is unlimited.

General structure

If (Condition 1)
{
// Do the thing a
}
else if (Condition 2)
{
 // Do the thing b
}
else
{
// Do the thing c
}
Examples
The following code is part of the temperature sensing system code:
if (temperature> = 70)
{
// Danger! Stop the system
}
else if (temperature> = 60 && temperature <70)
{
// Warning! You must send signals to alert the user
}
else
{
// Safety! Complete the normal tasks
}

Episode for iterative in Arduino

The for loop is used to duplicate a specific block of code a specified number
of times. In this loop, a counter is usually used to track the number of times
the code is duplicated and interrupted when a specified number is reached.
The for loop can be used with any iteration, and is frequently used with
arrays to perform a particular operation on elements that may be normal data
or specific legs.

General structure
for (step; condition; initial configuration) {
// code block to be replicated;
}

Initialization is performed only once at the start of loop execution. The

condition is checked every time the loop is repeated; if true, the block that
falls within the loop will be executed, then the step will be executed and the
condition will be re-checked. When the condition is not met (that is, the value
becomes false), the loop stops working.

Examples

The following code is part of the temperature sensing system code:

int PWMpin = 10; // LED light connected to sequence with 10 ohm

impedance of 10 foot

void setup ()
{
// This example does not require any configuration
}

void loop ()
{
for (int i = 0; i <= 255; i ++) {
analogWrite (PWMpin, i);
delay (10);
 }
}

Notes and warnings

The for loop in C is more flexible than for loops in some languages such as
BASIC. One or all of the three main elements can be removed from the loop,
keeping the semicolon intact. In addition, the initialization, condition, and
step expressions can be any valid C language expressions with unrelated
variables, and can use any of the data types in C, including decimals. Using
these unusual types of expressions with the for loop provides a solution to
some rare software problems.

For example, using the multiplication in the expression step will generate a
logarithmic progression such as:
for (int x = 2; x <100; x = x * 1.5) {
println (x);
}

This code will generate the following steps:

2,3,4,6,9,13,19,28,42,63,94

Another example of lighting up and gradually turning off LED light with just
one ring:
void loop ()
{
int x = 1;
for (int i = 0; i> -1; i = i + x) {
 analogWrite (PWMpin, i);
if (i == 255) x = -1; // Switch the direction of the step when the peak is reached
delay (10);
}
}
Goto keyword in arduino

The keyword goto moves the program to a specific position within the code.

goto label; // Send the program to execute the code block

// label found at the label

Examples

Example of using goto:

for (byte r = 0; r <255; r ++) {
for (byte g = 255; g> 0, g -) {
for (byte b = 0; b <255; b ++) {
if (analogRead (0)> 250) {goto bailout;}
// Something can be added here
}
}
}

bailout:

Notes and warnings

The goto statement is no longer used in C, and in some C programming

textbooks it is stated that the goto statement is no longer necessary but can be
used to simplify some programs. The reason why programmers are reluctant
to use the goto statement is that when they are overlooked, a program with an
unknown execution path will be created, making it almost impossible to track
and correct errors.

On the other hand, there are situations where the use of the word goto is
useful and greatly simplifies the code. One of these cases is a fork loop
fragmentation or a conditional if block at certain conditions.
Expression if conditional in Arduino

The conditional if expression verifies a given condition and executes the code
block written within it if it is true (ie its value is true).

General structure

if (condition)
{
// The block of code to execute when the condition is met
}

A condition is a logical expression whose value is either true or false.

Examples

An example of using the conditional if expression in multiple formats:

if (x> 120) digitalWrite (LEDpin, HIGH);

if (x> 120)
digitalWrite (LEDpin, HIGH);

if (x> 120) {digitalWrite (LEDpin, HIGH); }

if (x> 120) {
digitalWrite (LEDpin1, HIGH);
digitalWrite (LEDpin2, HIGH);
}
Notes and warnings

The given terms may require the use of one of the following parameters.

Budget transactions

x == y (y is equal to x)
x! = y (y is not equal to x)
x <y (y is exactly smaller than x)
x> y (y is exactly greater than x)
x <= y (y is smaller or equal to x)
x> = y (y is greater than or equal to x)

Be careful not to use only one equal sign (e.g. if (x = 10)). Equals (such as if
(x == 10)), which in this case is a equilibrium coefficient and checks if the
value of the variable x is equal to or not. The value of the last expression will
be true if the value of the variable x is 10, while the value of the previous
reference expression is always true.
The explanation of how C evaluates the expression if (x = 10) with true is
always that C assigns the value 10 to the variable x (remember that a single
equal sign is an attribution operator and has been used in error). The
conditional if expression then evaluates the value 10 - which becomes the
value of the variable x - as always true because the logical evaluation of any
non-zero number is always true. Consequently, the conditional if (x = 10)
expression will be assessed as verified and the result will be contrary to the
expectations expected at that time. In addition, the variable x will be set to
10, which is also not desirable
Keyword return in Arduino

The return keyword intersects the execution of any function and returns a
value from the function to the one who called it if specified.

General structure

return;

return value; // value In this format, the value will be returned

The returned value can be any type of variable or constants to be returned to

the one who called the function.

Examples

The following example demonstrates how to create a function to balance the

measured value of a sensor with a specific threshold:

int checkSensor () {
if (analogRead (0)> 400) {
return 1;
}
else {
return 0;
}
}
The following example shows how to use the return keyword to examine a
portion of the code without resorting to the comment method:

void loop () {

// This part of the code is checked

return;

// The part here which will not be implemented

// The error is probably within it
}
Expression switch ... case in Arduino

The switch ... case, as in if, verifies a specified value in a way that allows the
programmer to specify several codes, one of which is executed based on that
value. In more detail, the switch ... case balances the value of a variable with
the values specified within it; when the value of that variable matches one of
the values or expressions within it, the block associated with that value or
expression will be executed.

The break keyword is usually used at the end of each state of the switch ...
case to exit it after matching the state and executing the associated block. If
the key break is not used in that case, the switch ... case will continue to
examine the conditions and execute the associated blocks until the break is
reached or at the end.

General structure

switch (var) {
case label1:
// The first code that will be executed when the first case is matched
break;
case label2:
// The second code will be executed when the second case is matched
break;
default:
// The default code that will be executed when no case matches
// This case is optional
}

Transactions
var
The variable to balance its value with multiple values (states). Allowed data
types are: Integer, typeface.

lable1
The first constant that will be balanced with var. Allowed data types are:
Integer, typeface.

lable2
The second constant that will be balanced with var. Allowed data types are:
Integer, typeface.

Examples

An example of using the switch ... case expression to balance a variable value
and execute a code as appropriate:
switch (var) {
case 1:
// Value 1 var Do something when it equals
break;
case 2:
// Value 2 var Do something when it equals
break;
default:
// with any of the previous values var do something if it doesn't match
break;
}
While iterative episode in Arduino
The loop repeats while executing the code block within it continuously and infinitely as long as the
value of the logical condition in parentheses is true (see the general evidence); once the value of the
logical condition becomes false, the loop stops and exits. Any change in the value of the condition must
occur otherwise the loop will never come out, so the value of the variable that is checked within the
logical condition must be increased or decreased, or an external condition such as checking a sensitive
value or the like must be used.

General structure

while (condition) {
// block to be duplicated
}

Transactions

condition
A logical expression whose value is either true or false.

Examples

An example of using the while expression to repeat the execution of a code a certain number of times:

var = 0;
while (var <200) {
// The code written here will be repeated 200 times
var ++;
}
 Chapter V
Functions

Digital foot control functions in Arduino

The digitalRead () function in the Arduino

The digitalRead () function reads the value of a numeric foot that is either
HIGH or LOW.

General structure
digitalRead (pin)

Transactions
pin
A number indicating the digital man whose value is to be read.

Returned values
Returns the HIGH or LOW value representing the numeric pin foot value.

Examples
Set the value of foot 13 to the same value of foot 7 defined as input foot:

int ledPin = 13; // There is a LED light connected to the 13 foot digital
int inPin = 7; // Push button connected to 7 digital foot
int val = 0; // Changer to store the read value

void setup ()
{
pinMode (ledPin, OUTPUT); // 13 digital foot set as the output foot
pinMode (inPin, INPUT); // Set the 7 foot digital as the entered foot
}

void loop ()
{
val = digitalRead (inPin); // Read the income blood
digitalWrite (ledPin, val); // Adjust the light status to the value of the button
}

Notes and warnings

If you don't connect the foot with anything, the digitalRead () function can
return either HIGH or LOW (this may change randomly).
Similar input feet can also be used as digital feet, then referred to as A0, A1,
etc.
The digitalWrite () function in the Arduino

The digitalWrite () function writes either the HIGH value or the LOW value
on a specific numeric leg.

If the man is configured as an output (ie, OUTPUT) via the pinMode ()

function, that man's voltage is set to the corresponding value: 5V (or 3.3V in
3.3V panels) for HIGH, or 0V (ground) for LOW.

If the man is configured as an INPUT, it will activate (with HIGH) or disable

(with LOW) the digitalWrite (internal pullup resistor) function associated
with that input man. It is recommended that you use the INPUT_PULLUP
value with the pinMode () function to directly activate the internal lifting
resistance. See the "Digital Legs Tutorial" for more information.

If you do not configure a man to OUTPUT via the pinMode () function and
connect a LED light with it, the LED light may appear dim when calling
digitalWrite (HIGH) with this guy. Without explicitly configuring the man
via the pinMode () function, digitalWrite () will activate the internal lifting
resistance that will regulate the large current flowing then.

General structure

digitalWrite (pin, value)

Transactions
pin
A number indicating the numeric man on which to write the value.
value
The HIGH or LOW value to be written to the pin man.

Returned values

Nothing is returned.

Examples

Set the digital 13 man mode to the output man and then invert its value from
HIGH to LOW and vice versa every one second:

void setup ()
{
pinMode (13, OUTPUT); // 13 digital man set it as a man came out
}

void loop ()
{
digitalWrite (13, HIGH); // HIGH Adjust the value of 13 digital man to
delay (1000); // Waiting for one second to pass
digitalWrite (13, LOW); // LOW Adjust the value of the 13 digital man
to
delay (1000); // Waiting for one second to pass
}
Notes and warnings
Similar input legs can also be used as digital legs, then referred to as A0, A1,
etc.
The pinMode () function in the Arduino

The pinMode () function prepares a specific leg to perform either an input or

output behavior. See the "Digital Legs Tutorial" for more information about
leg functions.

Starting with the Arduino version 1.0.1, it became possible to activate the
internal lifting resistance by using the mode INPUT_PULLUP. In addition,
the INPUT mode automatically disables internal lifting resistors.

General structure
pinMode (pin, mode)
Transactions
pin
A number indicating the digital man to be configured to mode.

mode
The mode that determines the pin's behavior is either INPUT, OUTPUT, or
INPUT_PULLUP. A full explanation of the behavior and functions of digital
legs can be found on this page.

Returned values
Nothing is returned.

Examples
Set the digital 13 man mode to the output man and then invert its value from
HIGH to LOW and vice versa every one second:
void setup ()
{
pinMode (13, OUTPUT); // 13 digital man set it as a man came out
}

void loop ()
{
digitalWrite (13, HIGH); // HIGH Adjust the value of 13 digital man to
delay (1000); // Waiting for one second to pass
digitalWrite (13, LOW); // LOW Adjust the value of the 13 digital man to
delay (1000); // Waiting for one second to pass
}
Notes and warnings
Similar input legs can also be used as digital legs, then referred to as A0, A1,
etc.
Time functions in Arduino

The functions in this section deal with times and times, for example, to create
time delays with a certain value that some tasks require, or to perform a
specific process when a specific time period has passed since the board
started.

The delay () function in the Arduino

The delay () function pauses program execution for a specified period of time
(in milliseconds).

General structure

delay (ms)

Transactions

ms

An unsigned long number represents the time in milliseconds during which

the program is paused.

Reminder: There are 1,000 milliseconds per second.

Returned values
Nothing is returned.
Examples
Use the delay () function to pause the program from working for one second
before reversing the output case connected to LED light:
int ledPin = 13; // LED light connected to the man 13

void setup ()
{
pinMode (ledPin, OUTPUT); // As a man led out ledPin initialize the
man
}

void loop ()
{
digitalWrite (ledPin, HIGH); // turning the light on
delay (1000); // Wait for one second
digitalWrite (ledPin, LOW); // Turn off the light
delay (1000); // Wait for one second
}

Notes and warnings

Although it is very easy to create a flashing LED light with the delay ()
function and many codes use this function to create time delays required by
some tasks - such as using them to avoid the problem of button bounce when
pressed (button debouncing) - but using the delay () function In the code is
accompanied by a lot of disadvantages. During the execution of the delay
process when calling the function, the sensors' values will not be read, the
calculations will not be performed, and the condition of any man will not be
modified or controlled ... etc., so calling this function will interrupt the rest of
the tasks and operations and stop them for a period of time. Instead, look at
the millis () function and the example below to handle time delays and
control timing effectively. Experienced and knowledgeable programmers
usually avoid using the delay () function to delay events and control their
timing when the delay period exceeds a few tens of milliseconds unless the
written code is very simple.

Some things continue to work during Atmega's delay () control, such as

interrupts, as this does not disrupt it. The RX receiver's serial communication
is also recorded, the PWM values (written using analogWrite ()) and the leg
condition are preserved, and the interrupts continue to work as desired.

Arduino delayMicroseconds () function

The delayMicroseconds () function pauses program execution for a specified
period of time (in seconds). Currently, the largest value giving an accurate
time delay is 16383. This value can change in future Arduino versions. The
delay () function should be used instead of this function for time delays
longer than a few thousand microseconds.

General structure

delayMicroseconds (us)

Transactions
us
An unsigned int integer represents the time in the microsecond to which the
program is paused.

Reminder: There are 1,000 microseconds per millisecond, and 1,000,000

microseconds every 1 second.

Returned values
Nothing is returned.

Examples
The following code prepares the 8th man to act as an outgoing man. The man
then transmits a series of pulses of approximately 100 microseconds in
length. You should focus on the word "almost" because the time is absolutely
inaccurate and this is due to the loss of some time in the implementation of
other commands and instructions in the code:

int outPin = 8; // Label Man 8

void setup ()
{
pinMode (outPin, OUTPUT); // As a man came out outPin create the man
}

void loop ()
{
digitalWrite (outPin, HIGH); // Make the man's condition high
delayMicroseconds (50); // Pause for 50 microseconds
digitalWrite (outPin, LOW); // Make the man's condition low
delayMicroseconds (50); // Pause for 50 microseconds
}

Notes and warnings

This function works with absolute accuracy in the range between 3

microseconds and above. The delayMicroseconds () function cannot be
guaranteed to work accurately for time delays smaller than that value.

Starting with version 0018, the delayMicroseconds () function no longer

disables interrupts.

Arduino micros () function

The micros () function returns the Arduino board runtime of the current
program in microseconds.
The value calculated by this function will reach the state of rash (i.e. it will
return to zero) after about 70 minutes have passed. On Arduino 16MHz
boards (such as Duemilanove, and Nano), the accuracy of this function is 4
microseconds (that is, the value that the function returns is always a multiple
of 4). On Arduino boards running at 8 MHz (such as LilyPad), the accuracy
of this function is 8 microseconds.

General structure
time = micros ()
Returned values
Returns an unsigned long number representing the startup time of the current
program's Arduino board to the moment the micros () function is called.

Examples
Use the micros () function to find out how long the Arduino board started:
unsigned long time;

void setup () {
Serial.begin (9600);
}
void loop () {
Serial.print ("Time:");
time = micros ();

Serial.println (time); // Print the duration of the program since it started

working
 delay (1000); // Wait for one second not to send a huge amount of data
}

Notes and warnings

Remember: there are 1,000 microseconds in every one millisecond, and there
are 1,000,000 microseconds in every single second.

Arduino millis () function

The millis () function returns the Arduino board runtime for the current
program in milliseconds.

The value that this function calculates will reach the overflow state (i.e., it
will return to zero) after approximately 50 days.
General structure
time = millis ()
Returned values
An unsigned long number representing the start time of the current program's
Arduino board is returned to the moment the millis () function is called in
milliseconds.

Examples
Use the millis () function to find out since when the Arduino board started
working:
unsigned long time;

void setup () {
Serial.begin (9600);
}
void loop () {
Serial.print ("Time:");
time = millis ();

Serial.println (time); // Print the duration of the program since it

started working
delay (1000); // Wait for one second not to send a huge amount of data
}

Notes and warnings

Please note that the type of value returned by the millis () function is an
unsigned long number, so logical errors may occur if the programmer tries to
perform math operations with smaller types of numbers, such as int. Even
calculations with a signed long number can result in errors because its
maximum capacity is half that of the corresponding non-reference number.
Mathematical Functions in Arduino

Mathematical functions generally deal with numbers, as they perform various

mathematical operations on them, such as calculating an absolute value,
number root, sine, or random number generation.

() Abs
The abs () function calculates the absolute value of the number passed to it.

Constrain ()
The constrain () function limits a number within a specified field.

() Cos
The cos () function calculates the angle passed to it.

() Map
The map () function repositiones a number from the domain in which it is to
another domain.

() Max
The max () function returns the largest value passed to it.

() Min
Min () returns the smallest value passed to it.

() Pow
The pow () function calculates the value yx, that is, raises the base y to the
power x of the two values that are passed to it.

Random ()
The random () function generates and returns a pseudo-random number.

() Randomseed
The randomSeed () function creates the seed that the pseudo-random
numbers generator uses in the generation process.

() Sin
The sin () function calculates the sine of the angle passed to.

() Sq
The sq () function calculates the number of squared (multiplied by the
number itself) and returns it.

Sqrt ()
The sqrt () function calculates the square root of the number passed to it.

() Tan
The tan () function calculates the tangent of the angle passed to.
Handling and verifying typefaces in Arduino

These functions generally work with characters, verifying that a particular

character belongs to a particular set of characters.

isAlpha ()
The isAlpha () function checks if the passed character is an alphabetical
character.

isAlphaNumeric ()
The isAlphaNumeric () function checks if the character passed to it is an
alphabetical character or a number.

isAscii ()
The isAscii () function checks if the character passed to it is one of the Ascii
characters.

isControl ()
The isControl () function checks if the passed character is a control character.

isDigit ()
The isDigit () function checks if the passed character is a number.

isGraph ()
The isGraph () function checks to see if the typeface passed to it is printable
and contains some visible content (the blank is printable but does not have
visual content).
isHexadecimalDigit ()
IsHexadecimalDigit () verifies if the character passed is a hexadecimal digit
(hexadecimal digit); that is, it is between A-F or 9-0.

isLowerCase ()
The isLowerCase () function checks if the character passed to it is passed a
lower case alphabetical character.

isPrintable ()
IsPrintable () checks to see if the passed character is printable (i.e. one of the
characters that produces any output even if it is blank).

isPunct ()
The isPunct () function checks if the typeface passed to it is a punctuation
mark (i.e. is the typeface comma, semicolon, exclamation mark, etc.)?

isSpace ()
The isSpace () function checks if the character passed to it is a space.

isUpperCase ()
The isUpperCase () function checks if the character passed to it is a lower
case alphabetical character.

isWhitespace ()
The isWhitespace () function checks if the character passed to it is a white
space.
Arduino conversion functions

Conversion functions convert between different types of data in Arduino.

byte ()
The byte () function converts the value passed to it byte type.

char ()
The char () function converts the passed value to the char type.

float ()
The float () function converts the value passed to it (float).

int ()
The int () function converts the passed value to the integer type.

long ()
The long () function converts the value passed to the type “long”.

word ()
The word () function converts the passed value to the word type.
Provincial control functions in Arduino

The functions in this section control the districts in Arduino, activating or

disabling a specific interruption on a leg, or activating or disabling all
interrupts.

Attachinterrupt ()
The attachInterrupt () function activates a specific external interrupt on one of
the legs in the arduino board.

() Detachinterrupt
The detachInterrupt () function disables a specific external interruption
associated with one of the legs of the Arduino board.

() Interrupts
The interrupts () function deactivates interrupts after stopping it by calling the
nointerrupts () function.

() Nointerrupts
The noInterrupts () function disables all interrupts in the Arduino board.
Chapter VI
Additional tools
The keyword programm in Arduino

The keyword PROGMEM is used with variables when its data is to be stored
in program memory (flash memory) rather than in SRAM. For more
information about the types of memory available in Arduino, see this page.

The keyword PROGMEM is categorized under 'variable qualifier' and should

be used only with the data types defined in the pgmspace.h library. This word
tells the banker to place the variable data that you used with it in flash instead
of in SRAM where it should be stored in the normal state.

The PROGMEM keyword is part of the library pgmspace.h. This disc is

automatically included in recent versions of the Arduino IDE. However, if
you are using a version earlier than 1.0 (2011), the library must be manually
included at the beginning of your code using include #:

#include <avr / pgmspace.h>

General structure

const dataType variableName [] PROGMEM = {data0, data1, data3…};

DataType represents any type of data, and variableName is the name of the
array of data to be stored in flash memory. Be aware that since the key word
PROGMEM is constrained to a variable, there is no rule that requires it to be
in a specific place while declaring a variable; However, some tests have
suggested that PROGMEM, in different versions of Arduino (which uses the
Gulf banker), may work in a specific location only when declaring a variable.
The second example is tried in the examples section in the Arduino 13
version; the example might work better in earlier versions if PROGMEM is
placed after the variable name.

const dataType variableName [] PROGMEM = {};

const PROGMEM dataType variableName [] = {};
const dataType PROGMEM variableName [] = {};

Since it is possible to use the keyword PROGMEM with one variable, it is

better to use it with an array (or any similar structure in C to store data,
whether mentioned in this documentation or not) to contain the data to be
stored in flash memory if this data is large.
Using PROGMEM requires a two-step procedure. After storing the data in
the flash memory (the first step), special functions (functions) defined in the
pgmspace.h library must be used in order to read this data from the program's
memory and put it in the SRAM, so we can take advantage of this data and
use it.

Examples

The following code shows how to write data to flash memory and then read it
again:
// Memorize some integerless numbers
const PROGMEM uint16_t charSet [] = {65000, 32796, 16843, 10, 11234};

// Save some characters

const char signMessage [] PROGMEM = {"I AM PREDATOR, UNSEEN
COMBATANT. CREATED BY THE UNITED STATES DEPART"};

unsigned int displayInt;

int k; // counter variable
char myChar;

void setup () {
Serial.begin (9600);
while (! Serial); // Waiting for serial port connection

// Type here anything you want to configure and execute it once

// Re-read whole numbers
for (k = 0; k <5; k ++)
{
displayInt = pgm_read_word_near (charSet + k);
Serial.println (displayInt);
}
Serial.println ();

// Re-read the characters

 for (k = 0; k <strlen_P (signMessage); k ++)
{
myChar = pgm_read_byte_near (signMessage + k);
Serial.print (myChar);
}

Serial.println ();
}

void loop () {
// Write here your program to execute it frequently

}
When working with a large amount of text, such as having a project on the
LCD, it is a good idea to create and configure an array of text strings to store
them. Since text strings themselves are arrays, a 2D matrix must be used. The
following example illustrates the idea of placing large data in program
memory:
/*
PROGMEM string demo
How to store a table of strings in program memory (flash),
and retrieve them.

Information summarized from:

http://www.nongnu.org/avr-libc/user-manual/pgmspace.html

Setting up a table (array) of strings in program memory is slightly

complicated, but
here is a good template to follow.

Setting up the strings is a two-step process. First define the strings.

*/

#include <avr / pgmspace.h>

const char string_0 [] PROGMEM = "String 0"; // is the string to store.
Others to suit your "String 0" series
const char string_1 [] PROGMEM = "String 1";
const char string_2 [] PROGMEM = "String 2";
const char string_3 [] PROGMEM = "String 3";
const char string_4 [] PROGMEM = "String 4";
const char string_5 [] PROGMEM = "String 5";

// Then create a table that points to these strings

const char * const string_table [] PROGMEM = {string_0, string_1, string_2,

string_3, string_4, string_5};

char buffer [30]; // Make sure that this matrix is large enough to
accommodate the largest text string

void setup ()
{
 Serial.begin (9600);
while (! Serial); // Wait for the serial port to connect
Serial.println ("OK");
}

void loop ()
{
/ * Requires the use of a strings table in memory
Use special functions to retrieve data
A text string from the strcpy_P program memory copies the function
(In our case buffer is the variable memory)
Big enough RAM Make sure that the portion is reserved in memory
To recover data from program memory
*/

for (int i = 0; i <6, i ++)

{
strcpy_P (buffer, (char *) pgm_read_word (& (string_table [i]))); //
Necessary casts and dereferencing, just copy.
Serial.println (buffer);
delay (500);
}
}
Notes and warnings
Please note that the variables must be either general variables or static local
variables (defined using the keyword static) in order to use the word
PROGMEM with it.

The following example will not work when placed into a variable:

const char long_str [] PROGMEM = "Hi, I would like to tell you a bit about
myself. \ n";

While the following declaration will work for a variable if it is defined

locally within a function:

const static char long_str [] PROGMEM = "Hi, I would like to tell you a bit
about myself. \ n"

Extended call F ()

When something like:

Serial.print ("Write something on the Serial Monitor");

The text string to be printed normally stored in RAM. If your code prints a lot
of scripts on the serial port, it will fill memory. If you have flash space, you
can easily invest it by storing these texts in it by using the following formula:

Serial.print (F ("Write something on the Serial Monitor that is stored in

FLASH"));

Chapter VII
Proteus

In this chapter, we will carry out the first experiment, which is lighting and
extinguishing the LED repeatedly. To ensure that all concepts and steps are
linked to each other, we will explain all the steps starting from how to create
a project on Proteus to extracting a Hex file that will be used to program
Arduino in addition to running the experiment and observing the results.
Also, the step-by-step explanation will be covered.

Circle design on proteas

1. Open Proteus 8 and choose new project.

2. Type the project name and filing location, then click Next.
3. Choose Create schematic from templates, then choose template (default).
. Choose do not create pcb as shown then choose Next.

5. Although there is a platform on Proteus to write and implement Arduino

codes, I prefer to use the main Arduino program, so choose the option
specified in the following way.

6. This is the project summary, we will create only schematic. After pressing
Finish we will be ready to place the devices and connect them together.

7. We will choose three devices, namely

Arduino UNO
220 ohm resistance
RED LED

The following steps explain how to choose the UNO and place it on the list of
devices that will be used in the design. In the same way, choose RED LED
and 220ohm resistance.
9. The following example shows how to place the Arduino on the schematic
space. In the same way, follow the following steps and put the resistance and
the LED.

10. After placing all the devices on the asmatic and connecting the ends, we
will have the following shape.

. What is missing now until the circle is complete? There is no doubt that it is
the Ground. To choose the Ground, follow the steps illustrated below. Thus,
we have completed the connection settings for the circuit on the protein
program.

Note:
Arduino board does not need to be connected to the power or even ground,
because Proteus does this process implicitly for you.

Writing the code on the Arduino program

1. Open the Arduino program, open a new project, write the following code,
then save the project with the name E1_LED_Blinking

const int LED_Pin = 13;

void setup () {
// put your setup code here, to run once:
pinMode (LED_Pin, OUTPUT);
}

void loop () {
// put your main code here, to run repeatedly:
digitalWrite (LED_Pin, HIGH);
delay (1000);
digitalWrite (LED_Pin, LOW);
delay (1000);
}

Code explanation:

The code begins by announcing the variables that are used within more than
one scope of the program. The "Scope" is the term enclosed in parentheses of
type {}. So we started by announcing the LED_Pin variable which was used
inside the setup and loop. The const command is used to ensure the value of
the variable is not changed again, and since the LED_Pin variable retains the
value of the port number, it must not be changed again. We note that the
value 13 has been assigned to the LED_Pin variable, because we have
connected the LED to port number 13. Inside the setup, the port type (port)
will be defined if it is output or input via the PinMode function. Inside the
loop, the code that is repeated continuously will be written non-stop. The
code inside the loop starts with the line (digitalWrite (LED_Pin, HIGH),
which means output 5 volts to the port called LED_Pin, after that we notice
the delay (1000) line, which means that the code will remain the same for a
period of 1 second, then we notice the presence of the line (digitalWrite)
LED_Pin, LOW through which 5 volts will be prevented from passing to port
13 and to ensure the continuity of the LED stops lighting for a period of 1
second had to put (delay) 1000 at the end of the loop also. If through the code
inside the loop it will light LED for one second and it will turn off for one
second and so it will continue without stopping.

2. Make a verification of the code by pressing the button shown in the figure
to make sure that the code does not contain any errors.

3. If the code is correct, you will see a message similar to the following
message under the Arduino program.

4. After making sure that the code is free from any errors, go to the sketch
menu and choose Export compiled Binary. This is to extract the hex file.
Which is used to program the microcontrollers.
. Going to the folder in which the project was saved, you will find a .hx file.
With the same name as the project.

6. Return to the circle in Proteus, press Arduino to add the script file as
shown in the following steps.
7. Turn on the circuit and notice how the LED lights up and then turns off
repeatedly.

8. Try to change the delay time to 500 instead of 1000, perform steps 2
through 7, and note the difference.

Debate

Suppose you write the code in the following image and ignore the delay delay
after the digitalWrite (LED_Pin, LOW). What do you expect to happen in
this case?

const int LED_Pin = 13;

void setup () {
// put your setup code here, to run once:
pinMode (LED_Pin, OUTPUT);
}

void loop () {
// put your main code here, to run repeatedly:
digitalWrite (LED_Pin, HIGH);
delay (1000);
digitalWrite (LED_Pin, LOW);
}

So let us do the implementation process, we will start from the loop and then
we will put 5 volts on the port called LED_Pin which is originally port
number 13. Then we will go to the second line to implement it and we find
delay by 1000 and since the delay function deals with the values in
milliseconds then this This means that the delay will continue for a period of
1 second, and this delay will remain on the last state the micro was on, so the
LED will be lit for a period of 1 second, that is, until the delay command
ends. Now we are going to execute the third line which contains the
command (digitalWrite (LED_Pin, LOW) in which the LED will be turned
off. Well the LED has turned off now but then what? Focus on me well here
we are inside the loop function and therefore the code will start executing
again from the first A line inside the loop in which the command that will
output 5 volts to the LED and it will illuminate again! Here lies the problem
where the last line will be executed and immediately after it the first line will
be executed and on it the eye will not be able to notice that the LED has gone
out because the implementation of the code is calculated in microseconds for
that The delay had to be put after the command that required the LED to be
turned off.
 Chapter VIII

Matrices and loops for and condition if to control LEDs

In this lesson we will control four LED lights, each lamp will be controlled
by push button. What we will learn here is how to put the ports connected
with the LEDs in one variable is an Array, and the same for the switches will
also be placed in one array. In this way the code will be shorthand and more
professional. The lesson also discusses how to use the for loops to access the
elements of an array and the values saved in them. Also, it will explain how
to execute an order based on the fulfillment of a specific condition.

Circle design on Proteus

Open Proteus and design the circle as shown in the following figure
Explanation of the circuit

Four push buttons were connected with the Arduino ports from port number 1 to port number 4, the
ports were set to internally contain a pull-up resistance so there would be no need to connect resistors
or voltage sources with the push buttons and therefore it will work through the inverse logic When a
specific button is pressed, that port will read the logic LOW, and when a button is not pressed, that port
will read the logic HIGH and this is what should be considered in the code (you can review Lesson Six,
there is a complete experiment to understand this method). For LEDs, they are connected to ports 9
through 12 via a resistance of 220 ohms used to reduce current. In the code we will make each button
illuminate only one LED.

Writing the code on the Arduino program

Write the following code on the Arduino program then extract the Hex file and program the Arduino as
described in Lesson 4.
int pushButtons [4] = {1,2,3,4};
int ledPins [4] = {9,10,11,12};

void setup () {
// put your setup code here, to run once:
for (int i = 0; i <4; i ++)
{
pinMode (pushButtons [i], INPUT);
pinMode (ledPins [i], OUTPUT);
digitalWrite (pushButtons [i], HIGH); // activate pullup resistor
}
}

void loop () {
// put your main code here, to run repeatedly:
for (int i = 0; i <4; i ++)
{
int val = digitalRead (pushButtons [i]);
if (val == 0)
digitalWrite (ledPins [i], HIGH);
else
digitalWrite (ledPins [i], LOW);
}
}

Code explanation

The code begins with defining global variables that will work within the setup and loop fields. We
defined two matrices of the integer type, each matrix consists of four elements. In the first matrix,
which is called pushButtons, the port numbers connected with the pushButtons are assigned, and they
are ports 1 through 4. Likewise, for the second matrix, which is called ledPins, the port numbers
connected to the LEDs were placed inside The array, which is ports 9 through 12. We have to note that
after the name of the array, the number of elements of the array is enclosed in parentheses such as [4].

int pushButtons [4] = {1,2,3,4};

int ledPins [4] = {9,10,11,12};

As for the code inside the setup area, as we previously learned, it is often used to set the position of
ports so that they are either in the input or output state. But before explaining the code in the setup
field, we will first discuss some of the basic concepts related to matrices.

The numbering of the elements inside the matrices begins with the number 0, for example the first
element in the ledPins array is [0] ledPins which contains the value 9 and from this we conclude that
the second element in the array is element number 1 and so on. So [0] ledPins is a variable that contains
the value 9, and if we call it at any time, it means that we called the value inside of it which is 9 unless
it is changed. Since port number 9 is connected to an LED, it must be set to function as an output port,
the following code explains this step:

pinMode (ledPins [0], OUTPUT);

Notice that the number 0 is inside the ledPins matrix, which indicates element zero, which has a value
of 9. Now we want to set all ports from 9 through 12 in order to work as output ports because they are
connected with LEDs. We can do this through the following code inside the setup function.

void setup () {
pinMode (ledPins [0], OUTPUT);
pinMode (ledPins [1], OUTPUT);
pinMode (ledPins [2], OUTPUT);
pinMode (ledPins [3], OUTPUT);
}

In the above code we have called the pinMode function on each line to set the ports to work either in
the case of the output or the input, the input (Arguments) that will be passed to the function is the port
number and the state that must work on it (input / output), and since we deal with the connected ports
With LEDs, the status will always be the output. As for port numbers, they were previously defined
inside the ledPins array, so on each line the name of the array along with the element number will be
placed inside the pinMode function. This code is true one hundred percent, but it lacks professionalism
and explains that its writer is a little weak with programming, but why? Imagine if the number of ports
inside the array is 10, this means that we will write 10 lines to define the port type to act as the output
port. But what is the professional way? It is best to use iterative loops to shrink the code and make it
more professional and flexible. We will be using the for loop as shown in the following code.

for (int i = 0; i <4; i ++)

{
pinMode (ledPins [i], OUTPUT);
}

In the above code, we used the for loop and inside the definition of for, we defined the variable i, which
is of the integer type, and we assigned the initial value to it 0 because the first element in the array
starts with zero. Now let's implement for loop together. In the first cycle, the value of i will be equal to
0. This value will be compensated inside the code inside the for loop field, so the code will be as
follows (pinMode (ledPins [0], OUTPUT), after executing all the code inside the field of for loop The
for will implement the partial code that will affect the value of i and in this code is ++ i, which means
that the variable i will become its value equal to one, now the for will test the condition i <4 and
certainly the condition will be met because the value of i now is one and it is actually less Of 4. And
since the condition is met, we can now execute what is inside the for loop, and this time do not forget
that the value of i has become one, so the variable will be compensated To enter pin to become the
pinMode (ledPins [1], OUTPUT code, and by executing port number ten, it will be set in the output
state. the work.
In the same way, we can set the matrix of the input ports that extend from port number 1 to 4, and the
code for them can be added to the for loop inside the tuning of the output ports. It is very important to
note that port numbers 1 through 4 are numbers inside the array while the array itself starts from
element 0 and will end with element 3 because it has four elements.

void setup () {
for (int i = 0; i <4; i ++)
{
pinMode (pushButtons [i], INPUT);
pinMode (ledPins [i], OUTPUT);
}
}
Finally, we will add a partial code that will make the input ports linked to the internal pull up resistance
to the iterative loop where it will operate with the same previous concept.

void setup () {
for (int i = 0; i <4; i ++)
{
pinMode (pushButtons [i], INPUT);
pinMode (ledPins [i], OUTPUT);
digitalWrite (pushButtons [i], HIGH); // activate pullup resistor
}
}

So far we have finished the code for setting the port mode, but what about the code inside the loop
function? As you know, the code in the loop is the code responsible for implementing the basic idea.

The code inside the loop function is a code that is executed continuously to infinity. When you reach
the last line of the function, the function starts to work again starting from the first line. It is worth
noting here that the microcontroller on the Arduino Uno board is ATMEGA328P connected to a clock
source operating at 16 MHz and almost the microcontroller performs one operation per clock pulse, that
is, we can say that the microcontroller can implement 16 million instructions per second! I deliberately
mentioned this information now because the code in the loop in this lesson depends on this feature and
you will not be able to understand it until you feel the speed with which the microcontroller works.

void loop () {
// put your main code here, to run repeatedly:
for (int i = 0; i <4; i ++)
{
int val = digitalRead (pushButtons [i]);
if (val == 0)
digitalWrite (ledPins [i], HIGH);
else
digitalWrite (ledPins [i], LOW);
}
}
The code starts with a for loop that runs from 0 to 3, you will start by placing the value 0 in the variable
i and the code inside the loop will be executed. In the first line inside the loop, we defined the variable
val of the integer type, in which the value in port 1 will be read, i.e. [push button [0], if the push button
is pressed, the digitalRead function will read the value 0 and in the opposite case it will read the value 1
then this will be put The value in the variable val. Then the microcontroller will implement the if else
condition function and will test the condition if the val variable contains the value 0 or LOW then if the
condition is met the value of HIGH will be placed on the port associated with the variable [ledPins [0
and if the condition is not met the value LOW will be placed on the port associated with the variable [
ledPins [0 So we ran the first iterative loop in which the value of the variable i was equal to zero. The
function will continue to work and each time you increase the value of i by one and then execute the
code with the new value of i until it becomes i equal to 3, the code is executed based on this value and
then the value of i returns again to 0.

Now suppose that you have implemented the code and loaded it into the Arduino and then pressed the
button connected to port number 3 located in [pushbutton [2. Actually, the code in the loop function
will test all pushbuttons from [pushbutton [0 to reach [pushbutton] 3 but this will be done very quickly
and each time when it passes the test of the condition related to [pushbutton [2] which will light the
LED connected to port number 11.