Arduino Language Reference

2019
First Edition
 By Max Beerbohm

Moaml mohmmed

mEmlnc.com

Introduction
Arduino Coding Environment and basic tools
What language is Arduino?
Arduino IDE
Chapter One
Transactions in Arduino language
Arithmetic transactions in Arduino
Budget transactions in Arduino
 Boolean transactions in Arduino
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
Arduino sizeof () function
Notes and warnings
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"));

Arduino sizeof () function

The sizeof () function returns the memory size reserved in bytes for a specified variable or array.

General structure

sizeof (variable)

Transactions

variable

A variable of any type of data whose volume is intended, or an array whose current size is to be
defined.

Returned values
Returns the number of bytes reserved by the variable or array.

Examples
The sizeof () function is very useful for dealing with arrays (such as string strings) that are subject to
change in size without affecting other parts of the program. The following example prints each string
character separately. Try this example with changing myStr text string and see what you're going to
get:

char myStr [] = "this is a test";

int i;

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

void loop () {
for (i = 0; i <sizeof (myStr) - 1; i ++) {
 Serial.print (i, DEC);
Serial.print ("=");
Serial.write (myStr [i]);
Serial.println ();
}
delay (5000); // Wait a bit before repeating the process

Notes and warnings

Note that the sizeof () function returns the total number of bytes; therefore, if the size of the variables
stored in an array is greater than one byte, the iteration loop should look similar to the following
example:
for (i = 0; i <(sizeof (myInts) / sizeof (int)); i ++) {
// myInts [i] Do something with the elements of the array
}

Also, note that the perfectly formatted text string ends in null (ASCII 0).