Arduino Quick Guide123

ARDUINO QUICK GUIDE
ARDUINO OVERVIEW
Arduino is a prototype platform open source based on an easy-to-use hardware and software. It consists of a
circuit board, which can be programmed (referred to as a microcontroller) and a ready-made software
called Arduino IDE Integrated Development Environment, which is used to write and upload the
computer code to the physical board.
The key features are
1.Arduino boards are able to read analog or digital input signals from different sensors and turn it into an output
such as activating a motor, turning LED on/off, connect to the cloud and many other actions.
2.You can control your board functions by sending a set of instructions to the microcontroller on the
board via Arduino IDE.
3. To load a new code onto the board, use a USB cable.
4. Arduino IDE uses a simplified version of C++, making it easier to learn to program.
5. Arduino provides a standard form factor that breaks the functions of the micro-controller into a more
accessible package.
BOARD TYPES
Various kinds of Arduino boards are available depending on different microcontrollers used. However, all Arduino
boards have one thing in common: they are programmed through the Arduino IDE.
The differences are based on the number of inputs and outputs, the number of sensors, LEDs, and buttons
you can use on a single board , speed, operating voltage etc.
Board Name Operating Clock Digital Analog PWM UART Programming

i/o
Volt Speed Inputs Interface
Arduino Uno R3 USB via
5V 16MHz 14 6 6 1
ATMega16U2
ARDUINO BOARD DESCRIPTION

(1)Power USB: Arduino board can be powered by using the USB cable from your computer. All you need to do
is connect the USB cable to the USB connection 1.
(2)Power Barrel Jack: Arduino boards can be powered directly from the AC mains power supply by connecting
it to the Barrel Jack 2.
(3)Voltage Regulator: The function of the voltage regulator is to control the voltage given to the Arduino board
and stabilize the DC voltages used by the processor and other elements.
(4)Crystal Oscillator: The crystal oscillator helps Arduino in dealing with time issues. How does Arduino
calculate time? The answer is, by using the crystal oscillator. The number printed on top of the Arduino crystal is
16.000H9H. It tells us that the frequency is 16,000,000 Hertz or 16 MHz.
(5,17) Arduino Reset: You can reset your Arduino board, i.e., start your program from the beginning. You can
reset the UNO board in two ways. First, by using the reset button 17 on the board. Second, you can connect an
external reset button to the Arduino pin labelled RESET 5.
(6,7,8,9) Pins (3.3, 5, GND, Vin)

 3.3V (6) − Supply 3.3 output volt
 5V (7) − Supply 5 output volt
 GND (8)(Ground) − to ground your circuit.
 Vin (9) − This pin also can be used to power the Arduino board from an external power source, like AC mains
power supply.
(10) Analog pins: The Arduino UNO board has five analog input pins A0 through A5. These pins can read the
signal from an analog sensor like the humidity sensor or temperature sensor and convert it into a digital value that
can be read by the microprocessor.
(11) Main microcontroller: Each Arduino board has its own microcontroller . It is the brain of your board. The
main IC on the Arduino is different from board to board. The microcontrollers are usually of the ATMEL
Company. You must know what IC your board has before loading up a new program from the Arduino IDE.
(12) ICSP pin: Mostly, ICSP is an AVR, a tiny programming header for the Arduino consisting of MOSI, MISO,
SCK, RESET, VCC, and GND. It is often referred to as an SPI (Serial Peripheral Interface), which could be
considered as an "expansion" of the output. Actually, you are slaving the output device to the master of the SPI
bus.
(13) Power LED indicator: This LED should light up when you plug your Arduino into a power source to indicate
that your board is powered up correctly. If this light does not turn on, then there is something wrong with the
connection.
(14) TX and RX LEDs: On your board, you will find two labels: TX (transmit) and RX (receive). They appear in
two places on the Arduino UNO board. First, at the digital pins 0 and 1, to indicate the pins responsible for serial
communication. Second, the TX and RX led (13). The TX led flashes with different speed while sending the serial
data. The speed of flashing depends on the baud rate used by the board. RX flashes during the receiving process.
(15) Digital I/O: The Arduino UNO board has 14 digital I/O pins (15) (of which 6 provide PWM (Pulse Width
Modulation) output. These pins can be configured to work as input digital pins to read logic values (0 or 1) or as
digital output pins to drive different modules like LEDs, relays, etc. The pins labeled “~” can be used to generate
PWM.
(16) AREF: AREF stands for Analog Reference. It is sometimes, used to set an external reference voltage
(between 0 and 5 Volts) as the upper limit for the analog input pins.
ARDUINO INSTALLATION
In this section, we will learn in easy steps, how to set up the Arduino IDE on our computer and prepare the board
to receive the program via USB cable.
Step 1 − First you must have your Arduino board and a USB cable. In case you use Arduino UNO, you will need
a standard USB cable (A plug to B plug).In case you use Arduino Nano, you will need an A to Mini-B cable.
Step 2 − Download Arduino IDE Software.
You can get different versions of Arduino IDE from the Download page on the Arduino Official website. You
must select your software, which is compatible with your operating system (Windows, IOS, or Linux) and install.
Step 3 − Power up your board.
The Arduino Uno automatically draw power from either, the USB connection to the computer or an external
power supply. Connect the Arduino board to your computer using the USB cable. The green power LED (labeled
PWR) should glow.
Step 4 − Launch Arduino IDE.
Double-click the arduino icon to start the IDE.
Step 5 − Open your first project.
Once the software starts, you have two options −Create a new project and Open an existing project example.
To create a new project, select File → New.
To open an existing project example, select File → Example → Basics → Blink.
Here, we are selecting just one of the examples with the name Blink. It turns the LED on and off with some time
delay. You can select any other example from the list.
Step 6 − Select your Arduino board.
To avoid any error while uploading your program to the board, you must select the correct Arduino board name,
which matches with the board connected to your computer.
Go to Tools → Board and select your board.
Step 7 − Select your serial port.
Select the serial device of the Arduino board. Go to Tools → Serial Portmenu. This is likely to be COM3 or
higher (COM1 and COM2 are usually reserved for hardware serial ports). To find out, you can disconnect your
Arduino board and re-open the menu, the entry that disappears should be of the Arduino board. Reconnect the
board and select that serial port.
Step 8 − Upload the program to your board.
Before explaining how we can upload our program to the board, we must demonstrate the function of each
symbol appearing in the Arduino IDE toolbar.
A − Used to check if there is any compilation error.

B − Used to upload a program to the Arduino board.
C − Shortcut used to create a new sketch.
D − Used to directly open one of the example sketch.
E − Used to save your sketch.
F − Serial monitor used to receive serial data from the board and send the serial data to the board.
Now, simply click the "Upload" button in the environment. Wait a few seconds; you will see the RX and TX
LEDs on the board, flashing. If the upload is successful, the message "Done uploading" will appear in the status
bar.
Note − If you have an Arduino Mini, NG, or other board, you need to press the reset button physically on the
board, immediately before clicking the upload button on the Arduino Software.
ARDUINO PROGRAM STRUCTURE
Arduino programs can be divided in three main parts: Structure, Values(variables and constants), and Functions.
Let us start with the Structure.
Software structure consist of two main functions −Setup( ) function and Loop( ) function.
Void setup ( ) {
}
 PURPOSE − The setup() function is called when a sketch starts. Use it to initialize the variables, pin
modes, start using libraries, etc. The setup function will only run once, after each power up or reset of the
Arduino board.
 INPUT − -
 OUTPUT − -
 RETURN − -
Void Loop ( ) {
}
 PURPOSE − After creating a setup() function, the loop() function loops consecutively, allowing your
program to change and respond.
 INPUT − -
 OUTPUT − -
 RETURN − -
ARDUINO DATATYPES
Data types in C refers to an extensive system used for declaring variables or functions of different types. The type
of a variable determines how much space it occupies in the storage and how the bit pattern stored is interpreted.
The following table provides all the data types that you will use during Arduino programming.
void Boolean char Unsigned char byte int Unsigned int word
long Unsigned long short float double array String-char array String-object
void
The void keyword is used only in function declarations. It indicates that the function is expected to return no
information to the function from which it was called.
Example
Void Loop ( ) {
// rest of the code
}
Boolean
A Boolean holds one of two values, true or false. Each Boolean variable occupies one byte of memory.
Example
boolean val = false ; // declaration of variable with type boolean and initialize it with false
boolean state = true ; // declaration of variable with type boolean and initialize it with true
Char
A data type that takes up one byte of memory that stores a character value. Character literals are written in single
quotes like this: 'A' and for multiple characters, strings use double quotes: "ABC".
However, characters are stored as numbers. This means that it is possible to do arithmetic operations on
characters, in which the ASCII value of the character is used. For example, 'A' + 1 has the value 66, since the
ASCII value of the capital letter A is 65.
Example
Char chr_a = ‘a’ ;//declaration of variable with type char and initialize it with character a
Char chr_c = 97 ;//declaration of variable with type char and initialize it with character
unsigned char
Unsigned char is an unsigned data type that occupies one byte of memory. The unsigned char data type encodes
numbers from 0 to 255.
Example
Unsigned Char chr_y = 121 ; // declaration of variable with type Unsigned char and initialize it with character y
byte
A byte stores an 8-bit unsigned number, from 0 to 255.
Example
byte m = 25 ;//declaration of variable with type byte and initialize it with 25
int
Integers are the primary data-type for number storage. int stores a 16-bit (2-byte) value. This yields a range of -
32,768 to 32,767 (minimum value of -2^15 and a maximum value of (2^15) - 1).
The int size varies from board to board.
Example
int counter = 32 ;// declaration of variable with type int and initialize it with 32
Unsigned int
Unsigned ints (unsigned integers) are the same as int in the way that they store a 2 byte value. Instead of storing
negative numbers, however, they only store positive values, yielding a useful range of 0 to 65,535 (2^16) -
Example
Unsigned int counter = 60 ; // declaration of variable with
type unsigned int and initialize it with 60
Word
On the Uno and other ATMEGA based boards, a word stores a 16-bit unsigned number.
Example
word w = 1000 ;//declaration of variable with type word and initialize it with 1000
Long
Long variables are extended size variables for number storage, and store 32 bits (4 bytes), from -2,147,483,648 to
2,147,483,647.
Example
Long velocity = 102346 ;//declaration of variable with type Long and initialize it with 102346
unsigned long
Unsigned long variables are extended size variables for number storage and store 32 bits (4 bytes). Unlike
standard longs, unsigned longs will not store negative numbers, making their range from 0 to 4,294,967,295
(2^32 - 1).
Example
Unsigned Long velocity = 101006 ;// declaration of variable with
type Unsigned Long and initialize it with 101006
short
A short is a 16-bit data-type. This yields a range of -32,768 to 32,767 (minimum value of -2^15 and a maximum
value of (2^15) - 1).
Example
short val = 13 ;//declaration of variable with type short and initialize it with 13
float
Data type for floating-point number is a number that has a decimal point. Floating-point numbers are often used
to approximate the analog and continuous values because they have greater resolution than integers. They are
stored as 32 bits (4 bytes) of information.
Example
float num = 1.352;//declaration of variable with type float and initialize it with 1.352
double
Double precision floating-point number occupies four bytes. That is, the double implementation is exactly the
same as the float, with no gain in precision. On the Arduino Due, doubles have 8-byte (64 bit) precision.
Example
double num = 45.352 ;// declaration of variable with type double and initialize it with 45.
ARDUINO VARIABLES & CONSTANTS
Variables in C programming language have a property called scope. A scope is a region of the program and there
are three places where variables can be declared. They are −
 Inside a function or a block, which is called local variables.

 In the definition of function parameters, which is called formal parameters.
 Outside of all functions, which is called global variables.
Local Variables
Variables that are declared inside a function or block are local variables. They can be used only by the statements
that are inside that function or block of code. Local variables are not known to function outside their own.
Void setup () {
Void loop () {
int x , y ;
int z ; Local variable declaration
x = 0;
y = 0; actual initialization
z = 10;
Global Variables
Global variables are defined outside of all the functions, usually at the top of the program. The global variables
will hold their value throughout the life-time of your program.
A global variable can be accessed by any function. That is, a global variable is available for use throughout your
entire program after its declaration.
Int T , S ;
float c = 0 ; Global variable declaration
Void setup () {
Void loop () {
int x , y ;
int z ; Local variable declaration
x = 0;
y = 0; actual initialization
z = 10;
ARDUINO OPERATORS
An operator is a symbol that tells the compiler to perform specific mathematical or logical functions. The
different types of operators are
 Arithmetic Operators
 Comparison Operators
 Boolean Operators
 Bitwise Operators
 Compound Operators
Arithmetic Operators: Assume variable A holds 10 and variable B holds 20 then
Operator name Operator Description Example
simple
assignment Stores the value to the right of the equal sign in

= A=B
operator the variable to the left of the equal sign.
A + B will
addition + Adds two operands
give 30
A - B will
subtraction - Subtracts second operand from the first
give -10
A * B will
multiplication * Multiply both operands
give 200
B / A will
division / Divide numerator by denominator
give 2
Modulus Operator and remainder of after an B % A will

modulo %
integer division give 0
Comparison Operators: Assume variable A holds 10 and variable B holds 20 then

Operator Operator Description Example
name simple
Checks if the value of two operands is equal or not, if (A == B) is

equal to ==
yes then condition becomes true. not true
Checks if the value of two operands is equal or not, if (A != B) is

not equal to !=
values are not equal then condition becomes true. true
Checks if the value of left operand is less than the

(A < B) is
less than < value of right operand, if yes then condition becomes
true
true.
Checks if the value of left operand is greater than the

(A > B) is
greater than > value of right operand, if yes then condition becomes
not true
true.
Checks if the value of left operand is less than or equal

less than or (A <= B) is
<= to the value of right operand, if yes then condition
equal to true
becomes true.
greater than or (A >= B) is

>= Checks if the value of left operand is greater than or
equal to not true
equal to the value of right operand, if yes then
condition becomes true.
Boolean Operators: Assume variable A holds 10 and variable B holds 20 then

name simple
Called Logical AND operator. If both the operands are (A && B) is

and &&
non-zero then then condition becomes true. true
Called Logical OR Operator. If any of the two operands is (A || B) is

or ||
non-zero then then condition becomes true. true
Called Logical NOT Operator. Use to reverses the logical

!(A && B)
not ! state of its operand. If a condition is true then Logical
is false
NOT operator will make false.
Bitwise Operators: Assume variable A holds 60 and variable B holds 13 then

name simple
(A & B) will give

Binary AND Operator copies a bit to the result if
and & 12 which is 0000
it exists in both operands.
1100
Binary OR Operator copies a bit if it exists in (A | B) will give 61

or |
either operand which is 0011 1101
Binary XOR Operator copies the bit if it is set in (A ^ B) will give 49

xor ^
one operand but not both. which is 0011 0001
Binary Ones Complement Operator is unary and (~A ) will give -60
not ~
has the effect of 'flipping' bits. which is 1100 0011
Binary Left Shift Operator. The left operands A << 2 will give
shift left << value is moved left by the number of bits specified 240 which is 1111
by the right operand. 0000
Binary Right Shift Operator. The left operands

A >> 2 will give 15
shift right >> value is moved right by the number of bits
which is 0000 1111
specified by the right operand.
Compound Operators: Assume variable A holds 10 and variable B holds 20 then

Operator name Operator Description Example
simple
Increment operator, increases integer value by

increment ++ A++ will give 11
one
decrement -- A-- will give 9

Decrement operator, decreases integer value by
one
Add AND assignment operator. It adds right B += A is

compound
+= operand to the left operand and assign the equivalent to B =
addition
result to left operand B+ A
Subtract AND assignment operator. It subtracts B -= A is

compound
-= right operand from the left operand and assign equivalent to B =
subtraction
the result to left operand B-A
Multiply AND assignment operator. It B*= A is

compound
*= multiplies right operand with the left operand equivalent to B =
multiplication
and assign the result to left operand B* A
Divide AND assignment operator. It divides B /= A is

compound
/= left operand with the right operand and assign equivalent to B =
division
the result to left operand B/A
Modulus AND assignment operator. It takes B %= A is

compound
%= modulus using two operands and assign the equivalent to B =
modulo
result to left operand B%A
compound A |= 2 is same as
|= bitwise inclusive OR and assignment operator
bitwise or A=A|2
compound A &= 2 is same as

&= Bitwise AND assignment operator
bitwise and A=A&2
ARDUINO CONTROL STATEMENTS

Decision making structures require that the programmer specify one or more conditions to be evaluated or tested
by the program. It should be along with a statement or statements to be executed if the condition is determined to
be true, and optionally, other statements to be executed if the condition is determined to be false.
The general form of a decision making structure is
S.NO. Control Statement & Description
If statement
1 It takes an expression in parenthesis and a statement or block of statements. If the expression

is true then the statement or block of statements gets executed otherwise these statements are
skipped.
If …else statement
2 An if statement can be followed by an optional else statement, which executes when the
expression is false.
If…else if …else statement
3 The if statement can be followed by an optional else if...elsestatement, which is very useful to
test various conditions using single if...else if statement.
switch case statement
4 Similar to the if statements, switch...case controls the flow of programs by allowing the
programmers to specify different codes that should be executed in various conditions.
Conditional Operator ? :
5
The conditional operator ? : is the only ternary operator in C.
ARDUINO LOOPS
A loop statement allows us to execute a statement or group of statements multiple times. The general form of a
loop statement is
S.NO. Loop & Description
while loop
1
while loops will loop continuously, and infinitely, until the expression inside the parenthesis,
() becomes false. Something must change the tested variable, or the while loop will never exit.
do…while loop
2 The do…while loop is similar to the while loop. In the while loop, the loop-continuation
condition is tested at the beginning of the loop before performed the body of the loop.
for loop
3 A for loop executes statements a predetermined number of times. The control expression for
the loop is initialized, tested and manipulated entirely within the for loop parentheses.
Nested Loop
4 C language allows you to use one loop inside another loop. The following example illustrates
the concept.
Infinite loop
5
It is the loop having no terminating condition, so the loop becomes infinite.
ARDUINO FUNCTIONS
Functions allow structuring the programs in segments of code to perform individual tasks. The typical case for
creating a function is when one needs to perform the same action multiple times in a program.
advantages
 Functions help the programmer stay organized.
 Functions codify one action in one place.
 This also reduces chances for errors in modification, if the code needs to be changed.
 Functions make the whole sketch smaller and more compact.
 They make it easier to reuse code in other programs.
There are two required functions in an Arduino program i.e. setup () and loop(). Other functions must be created
outside the brackets of these two functions.
syntax
Function Declaration: A function is declared outside any other functions, above or below the loop function.
We can declare the function in two different ways.
The first way is writing the part of the function called a function prototype above the loop function, which
consists of
 Function return type

 Function name
 Function argument type, no need to write the argument name
Function prototype must be followed by a semicolon ( ; ).
int sum_func (int x, int y) // function declaration {
int z = 0;
z = x+y ;
return z; // return the value
void setup () {
Statements // group of statements
Void loop () {
int result = 0 ;
result = Sum_func (5,6) ; // function call
The second part, which is called the function definition or declaration, must be declared below the loop function,
which consists of −
 Function return type

 Function name
 Function argument type, here you must add the argument name
 The function body (statements inside the function executing when the function is called)
int sum_func (int , int ) ; // function prototype
void setup () {
Statements // group of statements
Void loop () {
int result = 0 ;
result = Sum_func (5,6) ; // function call
int sum_func (int x, int y) // function declaration {
int z = 0;
z = x+y ;
return z; // return the value
ARDUINO STRINGS
Strings are used to store text. They can be used to display text on an LCD or in the Arduino IDE Serial Monitor
window. Strings are also useful for storing the user input.
There are two types of strings in Arduino programming
 Arrays of characters, which are the same as the strings used in C programming.
 The Arduino String, which lets us use a string object in a sketch.
String Character Arrays
The first type of string is the string that is a series of characters of the type char. Array is a consecutive series of
the same type of variable stored in memory. A string is an array of char variables.
A string is a special array that has one extra element at the end of the string, which always has the value of 0
(zero). This is known as a "null terminated string".
void setup() {
char my_str[6]; // an array big enough for a 5 character string
Serial.begin(9600);
my_str[0] = 'H'; // the string consists of 5 characters
my_str[1] = 'e';
my_str[2] = 'l';
my_str[3] = 'l';
my_str[4] = 'o';
my_str[5] = 0; // 6th array element is a null terminator
Serial.println(my_str);
void loop() {
The following example shows what a string is made up of; a character array with printable characters and 0 as the
last element of the array to show that this is where the string ends. The string can be printed out to the Arduino
IDE Serial Monitor window by using Serial.println() and passing the name of the string.
void setup() {
char my_str[] = "Hello";
Serial.begin(9600);
void loop() {
In this sketch, the compiler calculates the size of the string array and also automatically null terminates the string
with a zero. An array that is six elements long and consists of five characters followed by a zero is created exactly
the same way as in the previous sketch.
Manipulating String Arrays

We can alter a string array within a sketch as shown in the following sketch.
void setup() {
char like[] = "I like coffee and cake"; // create a string
Serial.begin(9600);
// (1) print the string
Serial.println(like);
// (2) delete part of the string
like[13] = 0;
// (3) substitute a word into the string
like[13] = ' '; // replace the null terminator with a space
like[18] = 't'; // insert the new word
like[19] = 'e';
like[20] = 'a';
like[21] = 0; // terminate the string
void loop() {
Result
I like coffee and cake
I like coffee
I like coffee and tea
The sketch works in the following way.
Creating and Printing the String

In the sketch given above, a new string is created and then printed for display in the Serial Monitor window.
Shortening the String

The string is shortened by replacing the 14th character in the string with a null terminating zero (2). This is
element number 13 in the string array counting from 0.
When the string is printed, all the characters are printed up to the new null terminating zero. The other characters
do not disappear; they still exist in the memory and the string array is still the same size. The only difference is
that any function that works with strings will only see the string up to the first null terminator.
Changing a Word in the String

Finally, the sketch replaces the word "cake" with "tea" (3). It first has to replace the null terminator at like[13]
with a space so that the string is restored to the originally created format.
New characters overwrite "cak" of the word "cake" with the word "tea". This is done by overwriting individual
characters. The 'e' of "cake" is replaced with a new null terminating character. The result is that the string is
actually terminated with two null characters, the original one at the end of the string and the new one that replaces
the 'e' in "cake". This makes no difference when the new string is printed because the function that prints the
string stops printing the string characters when it encounters the first null terminator.
Functions to Manipulate String Arrays

The previous sketch manipulated the string in a manual way. To make it easier to manipulate string arrays, you
can write your own functions to do so, or use some of the string functions from the C language library.
void setup() {
char str[] = "This is my string"; // create a string
char out_str[40]; // output from string functions placed here

int num; // general purpose integer
Serial.begin(9600);
Serial.println(str);
// (2) get the length of the string (excludes null terminator)
num = strlen(str);
Serial.print("String length is: ");
Serial.println(num);
// (3) get the length of the array (includes null terminator)
num = sizeof(str); // sizeof() is not a C string function
Serial.print("Size of the array: ");
// (4) copy a string
strcpy(out_str, str);
Serial.println(out_str);
// (5) add a string to the end of a string (append)
strcat(out_str, " sketch.");
Serial.println(out_str);
num = strlen(out_str);
num = sizeof(out_str);
Serial.print("Size of the array out_str[]: ");
void loop() {
Result
This is my string
String length is: 17
Size of the array: 18
This is my string
This is my string sketch.
Size of the array out_str[]: 40
Print the String

The newly created string is printed to the Serial Monitor window as done in previous sketches.
Get the Length of the String

The strlen() function is used to get the length of the string. The length of the string is for the printable characters
only and does not include the null terminator.
The string contains 17 characters, so we see 17 printed in the Serial Monitor window.
Get the Length of the Array

The operator sizeof() is used to get the length of the array that contains the string. The length includes the null
terminator, so the length is one more than the length of the string.
sizeof() looks like a function, but technically is an operator. It is not a part of the C string library, but was used in
the sketch to show the difference between the size of the array and the size of the string (or string length).
Copy a String
The strcpy() function is used to copy the str[] string to the out_num[] array. The strcpy() function copies the
second string passed to it into the first string. A copy of the string now exists in the out_num[] array, but only
takes up 18 elements of the array, so we still have 22 free char elements in the array. These free elements are
found after the string in memory.
The string was copied to the array so that we would have some extra space in the array to use in the next part of
the sketch, which is adding a string to the end of a string.
Append a String to a String (Concatenate)

The sketch joins one string to another, which is known as concatenation. This is done using the strcat() function.
The strcat() function puts the second string passed to it onto the end of the first string passed to it.
After concatenation, the length of the string is printed to show the new string length. The length of the array is
then printed to show that we have a 25-character long string in a 40 element long array.
Remember that the 25-character long string actually takes up 26 characters of the array because of the null
terminating zero.
Array Bounds
When working with strings and arrays, it is very important to work within the bounds of strings or arrays. In the
example sketch, an array was created, which was 40 characters long, in order to allocate the memory that could be
used to manipulate strings.
If the array was made too small and we tried to copy a string that is bigger than the array to it, the string would be
copied over the end of the array. The memory beyond the end of the array could contain other important data used
in the sketch, which would then be overwritten by our string. If the memory beyond the end of the string is
overrun, it could crash the sketch or cause unexpected behavior.
ARDUINO STRING OBJECT

The second type of string used in Arduino programming is the String Object.
An object is a construct that contains both data and functions. A String object can be created just like a variable
and assigned a value or string. The String object contains functions (which are called "methods" in object oriented
programming (OOP)) which operate on the string data contained in the String object.
void setup() {
String my_str = "This is my string.";
Serial.begin(9600);
// (2) change the string to upper-case

my_str.toUpperCase();
// (3) overwrite the string
my_str = "My new string.";
// (4) replace a word in the string
my_str.replace("string", "Arduino sketch");
// (5) get the length of the string
Serial.println(my_str.length());
void loop() {
Result
This is my string.
THIS IS MY STRING.
My new string.
My new Arduino sketch.
A string object is created and assigned a value (or string) at the top of the sketch.
String my_str = "This is my string." ;
This creates a String object with the name my_str and gives it a value of "This is my string.".
This can be compared to creating a variable and assigning a value to it such as an integer −
int my_var = 102;
Printing the String

The string can be printed to the Serial Monitor window just like a character array string.
Convert the String to Upper-case

The string object my_str that was created, has a number of functions or methods that can be operated on it. These
methods are invoked by using the objects name followed by the dot operator (.) and then the name of the function
to use.
my_str.toUpperCase();
The toUpperCase() function operates on the string contained in the my_strobject which is of type String and
converts the string data (or text) that the object contains to upper-case characters. A list of the functions that the
String class contains can be found in the Arduino String reference. Technically, String is called a class and is used
to create String objects.
Overwrite a String
The assignment operator is used to assign a new string to the my_str object that replaces the old string
my_str = "My new string." ;
The assignment operator cannot be used on character array strings, but works on String objects only.
Replacing a Word in the String
The replace() function is used to replace the first string passed to it by the second string passed to it. replace() is
another function that is built into the String class and so is available to use on the String object my_str.
Getting the Length of the String

Getting the length of the string is easily done by using length(). In the example sketch, the result returned by
length() is passed directly to Serial.println() without using an intermediate variable.
When to Use a String Object

A String object is much easier to use than a string character array. The object has built-in functions that can
perform a number of operations on strings.
The main disadvantage of using the String object is that it uses a lot of memory and can quickly use up the
Arduinos RAM memory, which may cause Arduino to hang, crash or behave unexpectedly. If a sketch on an
Arduino is small and limits the use of objects, then there should be no problems.
Character array strings are more difficult to use and you may need to write your own functions to operate on these
types of strings. The advantage is that you have control on the size of the string arrays that you make, so you can
keep the arrays small to save memory.
ARDUINO TIME
Arduino provides four different time manipulation functions. They are −
S.No. Function & Description
delay () function
1
The way the delay() function works is pretty simple. It accepts a single integer (or number)
argument. This number represents the time (measured in milliseconds).
delayMicroseconds () function
2 The delayMicroseconds() function accepts a single integer (or number) argument. There are a
thousand microseconds in a millisecond, and a million microseconds in a second.
millis () function
3 This function is used to return the number of milliseconds at the time, the Arduino board
begins running the current program.
micros () function
The micros() function returns the number of microseconds from the time, the Arduino board
4
begins running the current program. This number overflows i.e. goes back to zero after
approximately 70 minutes.
ARDUINO ARRAYS
An array is a consecutive group of memory locations that are of the same type. To refer to a particular location or
element in the array, we specify the name of the array and the position number of the particular element in the
array.
The illustration given below shows an integer array called C that contains 11 elements. You refer to any one of
these elements by giving the array name followed by the particular element’s position number in square brackets
([]). The position number is more formally called a subscript or index (this number specifies the number of
elements from the beginning of the array). The first element has subscript 0 (zero) and is sometimes called the
zeros element.
Thus, the elements of array C are C[0] (pronounced “C sub zero”), C[1], C[2] and so on. The highest subscript in
array C is 10, which is 1 less than the number of elements in the array (11). Array names follow the same
conventions as other variable names.
A subscript must be an integer or integer expression (using any integral type). If a program uses an expression as
a subscript, then the program evaluates the expression to determine the subscript. For example, if we assume that
variable a is equal to 5 and that variable b is equal to 6, then the statement adds 2 to array element C[11].
A subscripted array name is an lvalue, it can be used on the left side of an assignment, just as non-array variable
names can.
Let us examine array C in the given figure, more closely. The name of the entire array is C. Its 11 elements are
referred to as C[0] to C[10]. The value of C[0] is -45, the value of C[1] is 6, the value of C[2] is 0, the value of
C[7] is 62, and the value of C[10] is 78.
To print the sum of the values contained in the first three elements of array C, we would write −
Serial.print (C[ 0 ] + C[ 1 ] + C[ 2 ] );
To divide the value of C[6] by 2 and assign the result to the variable x, we would write −
x = C[ 6 ] / 2;
Declaring Arrays
Arrays occupy space in memory. To specify the type of the elements and the number of elements required by an
array, use a declaration of the form −
type arrayName [ arraySize ] ;
The compiler reserves the appropriate amount of memory. (Recall that a declaration, which reserves memory is
more properly known as a definition). The arraySize must be an integer constant greater than zero. For example,
to tell the compiler to reserve 11 elements for integer array C, use the declaration −
int C[ 12 ]; // C is an array of 12 integers
Arrays can be declared to contain values of any non-reference data type. For example, an array of type string can
be used to store character strings.
Examples Using Arrays

Example 1: Declaring an Array and using a Loop to Initialize the Array’s Elements
The program declares a 10-element integer array n. Lines a–b use a Forstatement to initialize the array elements
to zeros. Like other automatic variables, automatic arrays are not implicitly initialized to zero. The first output
statement (line c) displays the column headings for the columns printed in the subsequent for statement (lines d–
e), which prints the array in tabular format.
Example
int n[ 10 ] ; // n is an array of 10 integers
void setup () {
void loop () {
for ( int i = 0; i < 10; ++i ) // initialize elements of array n to 0 {
n[ i ] = 0; // set element at location i to 0
Serial.print (i) ;
Serial.print (‘\r’) ;
for ( int j = 0; j < 10; ++j ) // output each array element's value {
Serial.print (n[j]) ;
Result
Element Value
0 0
1 0
2 0
3 0
4 0
5 0
6 0
7 0
8 0
9 0
Example 2: Initializing an Array in a Declaration with an Initializer List

The elements of an array can also be initialized in the array declaration by following the array name with an
equal-to sign and a brace-delimited comma-separated list of initializers. The program uses an initializer list to
initialize an integer array with 10 values (line a) and prints the array in tabular format (lines b–c).
// n is an array of 10 integers
int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 } ;
void setup () {
void loop () {
for ( int i = 0; i < 10; ++i ) // initialize elements of array n to 0 {
Serial.print (i) ;
for ( int j = 0; j < 10; ++j ) // output each array element's value {
Serial.print (n[j]) ;
Result
Element Value
0 32
1 27
2 64
3 18
4 95
5 14
6 90
7 70
8 60
9 37
Example 3: Summing the Elements of an Array

Often, the elements of an array represent a series of values to be used in a calculation. For example, if the
elements of an array represent exam grades, a professor may wish to total the elements of the array and use that
sum to calculate the class average for the exam. The program sums the values contained in the 10-element integer
array a.
const int arraySize = 10; // constant variable indicating size of array
int a[ arraySize ] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
int total = 0;
void setup () {
void loop () {
// sum contents of array a
for ( int i = 0; i < arraySize; ++i )
total += a[ i ];
Serial.print (“Total of array elements : ”) ;
Serial.print(total) ;
Result
Total of array elements: 849
S.NO. Concept & Description
1 Passing Arrays to Functions
To pass an array argument to a function, specify the name of the array without any brackets.
2 Multi-Dimensional Arrays
Arrays with two dimensions (i.e., subscripts) often represent tables of values consisting of
information arranged in rows and columns.
ARDUINO I/O FUNCTIONS

The pins on the Arduino board can be configured as either inputs or outputs. We will explain the functioning of
the pins in those modes. It is important to note that a majority of Arduino analog pins, may be configured, and
used, in exactly the same manner as digital pins.
Pins Configured as INPUT

Arduino pins are by default configured as inputs, so they do not need to be explicitly declared as inputs
with pinMode() when you are using them as inputs. Pins configured this way are said to be in a high-impedance
state. Input pins make extremely small demands on the circuit that they are sampling, equivalent to a series
resistor of 100 megaohm in front of the pin.
This means that it takes very little current to switch the input pin from one state to another. This makes the pins
useful for such tasks as implementing a capacitive touch sensor or reading an LED as a photodiode.
Pins configured as pinMode(pin, INPUT) with nothing connected to them, or with wires connected to them that
are not connected to other circuits, report seemingly random changes in pin state, picking up electrical noise from
the environment, or capacitively coupling the state of a nearby pin.
Pull-up Resistors
Pull-up resistors are often useful to steer an input pin to a known state if no input is present. This can be done by
adding a pull-up resistor (to +5V), or a pull-down resistor (resistor to ground) on the input. A 10K resistor is a
good value for a pull-up or pull-down resistor.
Using Built-in Pull-up Resistor with Pins Configured as Input

There are 20,000 pull-up resistors built into the Atmega chip that can be accessed from software. These built-in
pull-up resistors are accessed by setting the pinMode() as INPUT_PULLUP. This effectively inverts the behavior
of the INPUT mode, where HIGH means the sensor is OFF and LOW means the sensor is ON. The value of this
pull-up depends on the microcontroller used. On most AVR-based boards, the value is guaranteed to be between
20kΩ and 50kΩ. On the Arduino Due, it is between 50kΩ and 150kΩ. For the exact value, consult the datasheet
of the microcontroller on your board.
When connecting a sensor to a pin configured with INPUT_PULLUP, the other end should be connected to the
ground. In case of a simple switch, this causes the pin to read HIGH when the switch is open and LOW when the
switch is pressed. The pull-up resistors provide enough current to light an LED dimly connected to a pin
configured as an input. If LEDs in a project seem to be working, but very dimly, this is likely what is going on.
Same registers (internal chip memory locations) that control whether a pin is HIGH or LOW control the pull-up
resistors. Consequently, a pin that is configured to have pull-up resistors turned on when the pin is in
INPUTmode, will have the pin configured as HIGH if the pin is then switched to an OUTPUT mode with
pinMode(). This works in the other direction as well, and an output pin that is left in a HIGH state will have the
pull-up resistor set if switched to an input with pinMode().
Example
pinMode(3,INPUT) ; // set pin to input without using built in pull up resistor
pinMode(5,INPUT_PULLUP) ; // set pin to input using built in pull up resistor
Pins Configured as OUTPUT

Pins configured as OUTPUT with pinMode() are said to be in a low-impedance state. This means that they can
provide a substantial amount of current to other circuits. Atmega pins can source (provide positive current) or sink
(provide negative current) up to 40 mA (milliamps) of current to other devices/circuits. This is enough current to
brightly light up an LED (do not forget the series resistor), or run many sensors but not enough current to run
relays, solenoids, or motors.
Attempting to run high current devices from the output pins, can damage or destroy the output transistors in the
pin, or damage the entire Atmega chip. Often, this results in a "dead" pin in the microcontroller but the remaining
chips still function adequately. For this reason, it is a good idea to connect the OUTPUT pins to other devices
through 470Ω or 1k resistors, unless maximum current drawn from the pins is required for a particular
application.
pinMode() Function
The pinMode() function is used to configure a specific pin to behave either as an input or an output. It is possible
to enable the internal pull-up resistors with the mode INPUT_PULLUP. Additionally, the INPUT mode explicitly
disables the internal pull-ups.
Syntax
Void setup () {
pinMode (pin , mode);
}
 pin − the number of the pin whose mode you wish to set
 mode − INPUT, OUTPUT, or INPUT_PULLUP.
Example
int button = 5 ; // button connected to pin 5
int LED = 6; // LED connected to pin 6
void setup () {
pinMode(button , INPUT_PULLUP);
// set the digital pin as input with pull-up resistor
pinMode(button , OUTPUT); // set the digital pin as output

}
void setup () {
If (digitalRead(button ) == LOW) // if button pressed {
digitalWrite(LED,HIGH); // turn on led
delay(500); // delay for 500 ms
digitalWrite(LED,LOW); // turn off led
digitalWrite() Function
The digitalWrite() function is used to write a HIGH or a LOW value to a digital pin. If the pin has been
configured as an OUTPUT with pinMode(), its voltage will be set to the corresponding value: 5V (or 3.3V on
3.3V boards) for HIGH, 0V (ground) for LOW. If the pin is configured as an INPUT, digitalWrite() will enable
(HIGH) or disable (LOW) the internal pullup on the input pin. It is recommended to set the pinMode() to
INPUT_PULLUP to enable the internal pull-up resistor.
If you do not set the pinMode() to OUTPUT, and connect an LED to a pin, when calling digitalWrite(HIGH), the
LED may appear dim. Without explicitly setting pinMode(), digitalWrite() will have enabled the internal pull-up
resistor, which acts like a large current-limiting resistor.
Syntax
Void loop() {
digitalWrite (pin ,value);
}
 pin − the number of the pin whose mode you wish to set
 value − HIGH, or LOW.
int LED = 6; // LED connected to pin 6
void setup () {
pinMode(LED, OUTPUT); // set the digital pin as output
void setup () {
digitalWrite(LED,HIGH); // turn on led
digitalWrite(LED,LOW); // turn off led
analogRead( ) function
There is a difference between an on/off sensor (which detects the presence of an object) and an analog sensor,
whose value continuously changes. In order to read this type of sensor, we need a different type of pin.
In the lower-right part of the Arduino board, you will see six pins marked “Analog In”. These special pins not
only tell whether there is a voltage applied to them, but also its value. By using the analogRead() function, we
can read the voltage applied to one of the pins.
This function returns a number between 0 and 1023, which represents voltages between 0 and 5 volts. For
example, if there is a voltage of 2.5 V applied to pin number 0, analogRead(0) returns 512.
Syntax
analogRead(pin);
 pin − the number of the analog input pin to read from (0 to 5 on most boards, 0 to 7 on the Mini and Nano,
0 to 15 on the Mega)
int analogPin = 3;//potentiometer wiper (middle terminal)
// connected to analog pin 3
int val = 0; // variable to store the value read
void setup() {
Serial.begin(9600); // setup serial
void loop() {
val = analogRead(analogPin); // read the input pin
Serial.println(val); // debug value
ARDUINO ADVANCED I/O FUNCTION

analogReference() Function
Configures the reference voltage used for analog input (i.e. the value used as the top of the input range). The
options are −
 DEFAULT − The default analog reference of 5 volts (on 5V Arduino boards) or 3.3 volts (on 3.3V
Arduino boards)
 INTERNAL − An built-in reference, equal to 1.1 volts on the ATmega168 or ATmega328 and 2.56 volts
on the ATmega8 (not available on the Arduino Mega)
 INTERNAL1V1 − A built-in 1.1V reference (Arduino Mega only)
 INTERNAL2V56 − A built-in 2.56V reference (Arduino Mega only)
 EXTERNAL − The voltage applied to the AREF pin (0 to 5V only) is used as the reference
Syntax
analogReference (type);
type − can use any type of the follow (DEFAULT, INTERNAL, INTERNAL1V1, INTERNAL2V56,
EXTERNAL)
Do not use anything less than 0V or more than 5V for external reference voltage on the AREF pin. If you are
using an external reference on the AREF pin, you must set the analog reference to EXTERNAL before calling
the analogRead() function. Otherwise, you will short the active reference voltage (internally generated) and the
AREF pin, possibly damaging the microcontroller on your Arduino board.
Alternatively, you can connect the external reference voltage to the AREF pin through a 5K resistor, allowing you
to switch between external and internal reference voltages.
Note that the resistor will alter the voltage that is used as the reference because there is an internal 32K resistor on
the AREF pin. The two act as a voltage divider. For example, 2.5V applied through the resistor will yield 2.5 * 32
/ (32 + 5) = ~2.2V at the AREF pin.
Example
int analogPin = 3;// potentiometer wiper (middle terminal) connected to analog pin 3
int val = 0; // variable to store the read value
void setup() {
Serial.begin(9600); // setup serial
analogReference(EXTERNAL); // the voltage applied to the AREF pin (0 to 5V only)
// is used as the reference.
void loop() {
Serial.println(val); // debug value
ARDUINO - CHARACTER FUNCTIONS

All data is entered into computers as characters, which includes letters, digits and various special symbols. In this
section, we discuss the capabilities of C++ for examining and manipulating individual characters.
The character-handling library includes several functions that perform useful tests and manipulations of character
data. Each function receives a character, represented as an int, or EOF as an argument. Characters are often
manipulated as integers.
Remember that EOF normally has the value –1 and that some hardware architectures do not allow negative values
to be stored in char variables. Therefore, the character-handling functions manipulate characters as integers.
The following table summarizes the functions of the character-handling library. When using functions from the
character-handling library, include the <cctype> header.
S.No. Prototype & Description
int isdigit( int c )

1
Returns 1 if c is a digit and 0 otherwise.
int isalpha( int c )

2
Returns 1 if c is a letter and 0 otherwise.
int isalnum( int c )

3
Returns 1 if c is a digit or a letter and 0 otherwise.
int isxdigit( int c )
4 Returns 1 if c is a hexadecimal digit character and 0 otherwise.
(See Appendix D, Number Systems, for a detailed explanation of binary, octal, decimal and
hexadecimal numbers.)
int islower( int c )

5
Returns 1 if c is a lowercase letter and 0 otherwise.
int isupper( int c )

6
Returns 1 if c is an uppercase letter; 0 otherwise.
int isspace( int c )
7 Returns 1 if c is a white-space character—newline ('\n'), space
(' '), form feed ('\f'), carriage return ('\r'), horizontal tab ('\t'), or vertical tab ('\v')—and 0
otherwise.
int iscntrl( int c )

8
Returns 1 if c is a control character, such as newline ('\n'), form feed ('\f'), carriage return ('\r'),
horizontal tab ('\t'), vertical tab ('\v'), alert ('\a'), or backspace ('\b')—and 0 otherwise.
int ispunct( int c )

9
Returns 1 if c is a printing character other than a space, a digit, or a letter and 0 otherwise.
int isprint( int c )

10
Returns 1 if c is a printing character including space (' ') and 0 otherwise.
int isgraph( int c )

11
Returns 1 if c is a printing character other than space (' ') and 0 otherwise.
Examples
The following example demonstrates the use of the functions isdigit, isalpha, isalnum and isxdigit.
Function isdigit determines whether its argument is a digit (0–9). The function isalpha determines whether its
argument is an uppercase letter (A-Z) or a lowercase letter (a–z). The function isalnumdetermines whether its
argument is an uppercase, lowercase letter or a digit. Function isxdigit determines whether its argument is a
hexadecimal digit (A–F, a–f, 0–9).
Example 1
void setup () {
Serial.begin (9600);
Serial.print ("According to isdigit:\r");
Serial.print (isdigit( '8' ) ? "8 is a": "8 is not a");
Serial.print (" digit\r" );
Serial.print (isdigit( '8' ) ?"# is a": "# is not a") ;
Serial.print (" digit\r");
Serial.print ("\rAccording to isalpha:\r" );
Serial.print (isalpha('A' ) ?"A is a": "A is not a");
Serial.print (" letter\r");
Serial.print (isalpha('A' ) ?"b is a": "b is not a");
Serial.print (isalpha('A') ?"& is a": "& is not a");
Serial.print (isalpha( 'A' ) ?"4 is a":"4 is not a");
Serial.print ("\rAccording to isalnum:\r");
Serial.print (isalnum( 'A' ) ?"A is a" : "A is not a" );
Serial.print (" digit or a letter\r" );
Serial.print (isalnum( '8' ) ?"8 is a" : "8 is not a" ) ;
Serial.print (" digit or a letter\r");
Serial.print (isalnum( '#' ) ?"# is a" : "# is not a" );
Serial.print (" digit or a letter\r");
Serial.print ("\rAccording to isxdigit:\r");
Serial.print (isxdigit( 'F' ) ?"F is a" : "F is not a" );
Serial.print (" hexadecimal digit\r" );
Serial.print (isxdigit( 'J' ) ?"J is a" : "J is not a" ) ;
Serial.print (isxdigit( '7' ) ?"7 is a" : "7 is not a" ) ;

Serial.print (isxdigit( '$' ) ? "$ is a" : "$ is not a" );
Serial.print (isxdigit( 'f' ) ? “f is a" : "f is not a");
void loop () {
Result
According to isdigit:
8 is a digit
# is not a digit
According to isalpha:
A is a letter
b is a letter
& is not a letter
4 is not a letter
According to isalnum:
A is a digit or a letter
8 is a digit or a letter
# is not a digit or a letter
According to isxdigit:
F is a hexadecimal digit
J is not a hexadecimal digit
7 is a hexadecimal digit
$ is not a hexadecimal digit

f is a hexadecimal digit
We use the conditional operator (?:) with each function to determine whether the string " is a " or the string " is
not a " should be printed in the output for each character tested. For example, line a indicates that if '8' is a digit—
i.e., if isdigit returns a true (nonzero) value—the string "8 is a " is printed. If '8' is not a digit (i.e., if isdigit returns
0), the string " 8 is not a " is printed.
Example 2
The following example demonstrates the use of the functions islower and isupper. The
function islower determines whether its argument is a lowercase letter (a–z). Function isupper determines
whether its argument is an uppercase letter (A–Z).
int thisChar = 0xA0;
void setup () {
Serial.print ("According to islower:\r") ;
Serial.print (islower( 'p' ) ? "p is a" : "p is not a" );
Serial.print ( " lowercase letter\r" );
Serial.print ( islower( 'P') ? "P is a" : "P is not a") ;
Serial.print ("lowercase letter\r");
Serial.print (islower( '5' ) ? "5 is a" : "5 is not a" );
Serial.print ( " lowercase letter\r" );

Serial.print ( islower( '!' )? "! is a" : "! is not a") ;
Serial.print ("lowercase letter\r");
Serial.print ("\rAccording to isupper:\r") ;
Serial.print (isupper ( 'D' ) ? "D is a" : "D is not an" );
Serial.print ( " uppercase letter\r" );
Serial.print ( isupper ( 'd' )? "d is a" : "d is not an") ;
Serial.print (isupper ( '8' ) ? "8 is a" : "8 is not an" );
Serial.print ( islower( '$' )? "$ is a" : "$ is not an") ;
Serial.print ("uppercase letter\r ");
void setup () {
Result
According to islower:
p is a lowercase letter
P is not a lowercase letter
5 is not a lowercase letter
! is not a lowercase letter
According to isupper:
D is an uppercase letter
d is not an uppercase letter
8 is not an uppercase letter
$ is not an uppercase letter
Example 3
The following example demonstrates the use of functions isspace, iscntrl, ispunct, isprint and isgraph.
 The function isspace determines whether its argument is a white-space character, such as space (' '), form feed ('\f'), newline ('\n'),
carriage return ('\r'), horizontal tab ('\t') or vertical tab ('\v').
 The function iscntrl determines whether its argument is a control character such as horizontal tab ('\t'), vertical tab ('\v'), form feed
('\f'), alert ('\a'), backspace ('\b'), carriage return ('\r') or newline ('\n').
 The function ispunct determines whether its argument is a printing character other than a space, digit or letter, such as $, #, (, ), [, ], {,
}, ;, : or %.
 The function isprint determines whether its argument is a character that can be displayed on the screen (including the space character).
 The function isgraph tests for the same characters as isprint, but the space character is not included.
void setup () {
Serial.print ( " According to isspace:\rNewline ") ;
Serial.print (isspace( '\n' )? " is a" : " is not a" );

Serial.print ( " whitespace character\rHorizontal tab") ;
Serial.print (isspace( '\t' )? " is a" : " is not a" );
Serial.print ( " whitespace character\n") ;
Serial.print (isspace('%')? " % is a" : " % is not a" );
Serial.print ( " \rAccording to iscntrl:\rNewline") ;
Serial.print ( iscntrl( '\n' )?"is a" : " is not a" ) ;
Serial.print (" control character\r");
Serial.print (iscntrl( '$' ) ? " $ is a" : " $ is not a" );
Serial.print (" control character\r");
Serial.print ("\rAccording to ispunct:\r");
Serial.print (ispunct(';' ) ?"; is a" : "; is not a" ) ;
Serial.print (" punctuation character\r");
Serial.print (ispunct('Y' ) ?"Y is a" : "Y is not a" ) ;
Serial.print ("punctuation character\r");
Serial.print (ispunct('#' ) ?"# is a" : "# is not a" ) ;
Serial.print ("punctuation character\r");
Serial.print ( "\r According to isprint:\r");
Serial.print (isprint('$' ) ?"$ is a" : "$ is not a" );
Serial.print (" printing character\rAlert ");
Serial.print (isprint('\a' ) ?" is a" : " is not a" );
Serial.print (" printing character\rSpace ");
Serial.print (isprint(' ' ) ?" is a" : " is not a" );
Serial.print (" printing character\r");
Serial.print ("\r According to isgraph:\r");
Serial.print (isgraph ('Q' ) ?"Q is a" : "Q is not a" );
Serial.print ("printing character other than a space\rSpace ");
Serial.print (isgraph (' ') ?" is a" : " is not a" );
Serial.print ("printing character other than a space ");
void loop () {
Result
According to isspace:
Newline is a whitespace character
Horizontal tab is a whitespace character
% is not a whitespace character
According to iscntrl:
Newline is a control character
$ is not a control character
According to ispunct:
; is a punctuation character
Y is not a punctuation character
# is a punctuation character
According to isprint:
$ is a printing character
Alert is not a printing character
Space is a printing character
According to isgraph:
Q is a printing character other than a space
Space is not a printing character other than a space
ARDUINO - MATH LIBRARY

The Arduino Math library (math.h) includes a number of useful mathematical functions for manipulating floating-
point numbers.
Library Macros
Following are the macros defined in the header math.h −
Given below is the list of macros defined in the header math.h
Library Functions
The following functions are defined in the header math.h −
Given below is the list of functions are defined in the header math.h
Example
The following example shows how to use the most common math.h library functions −
double double__x = 45.45 ;
double double__y = 30.20 ;
void setup() {
Serial.begin(9600);
Serial.print("cos num = ");
Serial.println (cos (double__x) ); // returns cosine of x
Serial.print("absolute value of num = ");
Serial.println (fabs (double__x) ); // absolute value of a float
Serial.print("floating point modulo = ");
Serial.println (fmod (double__x, double__y)); // floating point modulo
Serial.print("sine of num = ");
Serial.println (sin (double__x) ) ;// returns sine of x
Serial.print("square root of num : ");
Serial.println ( sqrt (double__x) );// returns square root of x
Serial.print("tangent of num : ");
Serial.println ( tan (double__x) ); // returns tangent of x
Serial.print("exponential value of num : ");

Serial.println ( exp (double__x) ); // function returns the exponential value of x.
Serial.print("cos num : ");
Serial.println (atan (double__x) ); // arc tangent of x
Serial.print("tangent of num : ");
Serial.println (atan2 (double__y, double__x) );// arc tangent of y/x
Serial.print("arc tangent of num : ");
Serial.println (log (double__x) ) ; // natural logarithm of x
Serial.print("cos num : ");
Serial.println ( log10 (double__x)); // logarithm of x to base 10.
Serial.print("logarithm of num to base 10 : ");
Serial.println (pow (double__x, double__y) );// x to power of y
Serial.print("power of num : ");
Serial.println (square (double__x)); // square of x
void loop() {
Result
cos num = 0.10
absolute value of num = 45.45
floating point modulo =15.25
sine of num = 0.99
square root of num : 6.74
tangent of num : 9.67
exponential value of num : ovf
cos num : 1.55
tangent of num : 0.59
arc tangent of num : 3.82
cos num : 1.66
logarithm of num to base 10 : inf
power of num : 2065.70
ARDUINO - TRIGONOMETRIC FUNCTIONS

You need to use Trigonometry practically like calculating the distance for moving object or angular speed.
Arduino provides traditional trigonometric functions (sin, cos, tan, asin, acos, atan) that can be summarized by
writing their prototypes. Math.h contains the trigonometry function's prototype.
Trigonometric Exact Syntax

double sin(double x); //returns sine of x radians
double cos(double y); //returns cosine of y radians
double tan(double x); //returns the tangent of x radians
double acos(double x); //returns A, the angle corresponding to cos (A) = x
double asin(double x); //returns A, the angle corresponding to sin (A) = x
double atan(double x); //returns A, the angle corresponding to tan (A) = x
Example
double sine = sin(2); // approximately 0.90929737091
double cosine = cos(2); // approximately -0.41614685058

double tangent = tan(2); // approximately -2.18503975868
ARDUINO - PULSE WIDTH MODULATION

Pulse Width Modulation or PWM is a common technique used to vary the width of the pulses in a pulse-train.
PWM has many applications such as controlling servos and speed controllers, limiting the effective power of
motors and LEDs.
Basic Principle of PWM

Pulse width modulation is basically, a square wave with a varying high and low time. A basic PWM signal is
shown in the following figure.
There are various terms associated with PWM −
 On-Time − Duration of time signal is high.
 Off-Time − Duration of time signal is low.
 Period − It is represented as the sum of on-time and off-time of PWM signal.
 Duty Cycle − It is represented as the percentage of time signal that remains on during the period of the PWM signal.
Period
As shown in the figure, Ton denotes the on-time and Toff denotes the off-time of signal. Period is the sum of both
on and off times and is calculated as shown in the following equation −
Ttotal=Ton+ToffTtotal=Ton+Toff
Duty Cycle
Duty cycle is calculated as the on-time of the period of time. Using the period calculated above, duty cycle is
calculated as −
D=TonTon+Toff=TonTtotalD=TonTon+Toff=TonTtotal
analogWrite() Function
The analogWrite() function writes an analog value (PWM wave) to a pin. It can be used to light a LED at
varying brightness or drive a motor at various speeds. After a call of the analogWrite() function, the pin will
generate a steady square wave of the specified duty cycle until the next call to analogWrite() or a call to
digitalRead() or digitalWrite() on the same pin. The frequency of the PWM signal on most pins is approximately
490 Hz. On the Uno and similar boards, pins 5 and 6 have a frequency of approximately 980 Hz. Pins 3 and 11 on
the Leonardo also run at 980 Hz.
On most Arduino boards (those with the ATmega168 or ATmega328), this function works on pins 3, 5, 6, 9, 10,
and 11. On the Arduino Mega, it works on pins 2 - 13 and 44 - 46. Older Arduino boards with an ATmega8 only
support analogWrite() on pins 9, 10, and 11.
The Arduino Due supports analogWrite() on pins 2 through 13, and pins DAC0 and DAC1. Unlike the PWM
pins, DAC0 and DAC1 are Digital to Analog converters, and act as true analog outputs.
You do not need to call pinMode() to set the pin as an output before calling analogWrite().
analogWrite() Function Syntax

analogWrite ( pin , value ) ;
value − the duty cycle: between 0 (always off) and 255 (always on).
Example
int ledPin = 9; // LED connected to digital pin 9
int analogPin = 3; // potentiometer connected to analog pin 3
int val = 0; // variable to store the read value
void setup() {
pinMode(ledPin, OUTPUT); // sets the pin as output
void loop() {
analogWrite(ledPin, (val / 4)); // analogRead values go from 0 to 1023,
// analogWrite values from 0 to 255
ARDUINO - RANDOM NUMBERS

To generate random numbers, you can use Arduino random number functions. We have two functions −
 randomSeed(seed)
 random()
randomSeed (seed)
The function randomSeed(seed) resets Arduino’s pseudorandom number generator. Although the distribution of
the numbers returned by random() is essentially random, the sequence is predictable. You should reset the
generator to some random value. If you have an unconnected analog pin, it might pick up random noise from the
surrounding environment. These may be radio waves, cosmic rays, electromagnetic interference from cell phones,
fluorescent lights and so on.
Example
randomSeed(analogRead(5)); // randomize using noise from analog pin 5
random( )
The random function generates pseudo-random numbers. Following is the syntax.
random( ) Statements Syntax

long random(max) // it generate random numbers from 0 to max
long random(min, max) // it generate random numbers from min to max
Example
long randNumber;
void setup() {
Serial.begin(9600);
// if analog input pin 0 is unconnected, random analog
// noise will cause the call to randomSeed() to generate
// different seed numbers each time the sketch runs.
// randomSeed() will then shuffle the random function.
randomSeed(analogRead(0));
void loop() {
// print a random number from 0 to 299
Serial.print("random1=");
randNumber = random(300);
Serial.println(randNumber); // print a random number from 0to 299
Serial.print("random2=");
randNumber = random(10, 20);// print a random number from 10 to 19
Serial.println (randNumber);
delay(50);
Let us now refresh our knowledge on some of the basic concepts such as bits and bytes.
Bits
A bit is just a binary digit.
 The binary system uses two digits, 0 and 1.
 Similar to the decimal number system, in which digits of a number do not have the same value, the ‘significance’ of a bit depends on
its position in the binary number. For example, digits in the decimal number 666 are the same, but have different values.
Bytes
A byte consists of eight bits.
 If a bit is a digit, it is logical that bytes represent numbers.
 All mathematical operations can be performed upon them.
 The digits in a byte do not have the same significance either.
 The leftmost bit has the greatest value called the Most Significant Bit (MSB).
 The rightmost bit has the least value and is therefore, called the Least Significant Bit (LSB).
 Since eight zeros and ones of one byte can be combined in 256 different ways, the largest decimal number that can be represented by
one byte is 255 (one combination represents a zero).
ARDUINO – INTERRUPTS
Interrupts stop the current work of Arduino such that some other work can be done.
Suppose you are sitting at home, chatting with someone. Suddenly the telephone rings. You stop chatting, and
pick up the telephone to speak to the caller. When you have finished your telephonic conversation, you go back to
chatting with the person before the telephone rang.
Similarly, you can think of the main routine as chatting to someone, the telephone ringing causes you to stop
chatting. The interrupt service routine is the process of talking on the telephone. When the telephone conversation
ends, you then go back to your main routine of chatting. This example explains exactly how an interrupt causes a
processor to act.
The main program is running and performing some function in a circuit. However, when an interrupt occurs the
main program halts while another routine is carried out. When this routine finishes, the processor goes back to the
main routine again.
Important features
Here are some important features about interrupts −
 Interrupts can come from various sources. In this case, we are using a hardware interrupt that is triggered by a state change on one of
the digital pins.
 Most Arduino designs have two hardware interrupts (referred to as "interrupt0" and "interrupt1") hard-wired to digital I/O pins 2 and 3,
respectively.
 The Arduino Mega has six hardware interrupts including the additional interrupts ("interrupt2" through "interrupt5") on pins 21, 20, 19,
and 18.
 You can define a routine using a special function called as “Interrupt Service Routine” (usually known as ISR).
 You can define the routine and specify conditions at the rising edge, falling edge or both. At these specific conditions, the interrupt
would be serviced.
 It is possible to have that function executed automatically, each time an event happens on an input pin.
Types of Interrupts
There are two types of interrupts −
 Hardware Interrupts − They occur in response to an external event, such as an external interrupt pin going high or low.
 Software Interrupts − They occur in response to an instruction sent in software. The only type of interrupt that the “Arduino
language” supports is the attachInterrupt() function.
Using Interrupts in Arduino

Interrupts are very useful in Arduino programs as it helps in solving timing problems. A good application of an
interrupt is reading a rotary encoder or observing a user input. Generally, an ISR should be as short and fast as
possible. If your sketch uses multiple ISRs, only one can run at a time. Other interrupts will be executed after the
current one finishes in an order that depends on the priority they have.
Typically, global variables are used to pass data between an ISR and the main program. To make sure variables
shared between an ISR and the main program are updated correctly, declare them as volatile.
attachInterrupt Statement Syntax

attachInterrupt(digitalPinToInterrupt(pin),ISR,mode);//recommended for arduino board
attachInterrupt(pin, ISR, mode) ; //recommended Arduino Due, Zero only
//argument pin: the pin number
//argument ISR: the ISR to call when the interrupt occurs;
//this function must take no parameters and return nothing.
//This function is sometimes referred to as an interrupt service routine.
//argument mode: defines when the interrupt should be triggered.
The following three constants are predefined as valid values −
 LOW to trigger the interrupt whenever the pin is low.
 CHANGE to trigger the interrupt whenever the pin changes value.
 FALLING whenever the pin goes from high to low.
Example
int pin = 2; //define interrupt pin to 2
volatile int state = LOW; // To make sure variables shared between an ISR
//the main program are updated correctly,declare them as volatile.
void setup() {
pinMode(13, OUTPUT); //set pin 13 as output
attachInterrupt(digitalPinToInterrupt(pin), blink, CHANGE);
//interrupt at pin 2 blink ISR when pin to change the value
void loop() {
digitalWrite(13, state); //pin 13 equal the state value
void blink() {
//ISR function
state = !state; //toggle the state when the interrupt occurs
ARDUINO – COMMUNICATION
Hundreds of communication protocols have been defined to achieve this data exchange. Each protocol can be
categorized into one of the two categories: parallel or serial.
Parallel Communication
Parallel connection between the Arduino and peripherals via input/output ports is the ideal solution for shorter
distances up to several meters. However, in other cases when it is necessary to establish communication between
two devices for longer distances it is not possible to use parallel connection. Parallel interfaces transfer multiple
bits at the same time. They usually require buses of data - transmitting across eight, sixteen, or more wires. Data
is transferred in huge, crashing waves of 1’s and 0’s.
Advantages and Drawbacks of Parallel Communication
Parallel communication certainly has its advantages. It is faster than serial, straightforward, and relatively easy to
implement. However, it requires many input/output (I/O) ports and lines. If you have ever had to move a project
from a basic Arduino Uno to a Mega, you know that the I/O lines on a microprocessor can be precious and few.
Therefore, we prefer serial communication, sacrificing potential speed for pin real estate.
Serial Communication Modules

Today, most Arduino boards are built with several different systems for serial communication as standard
equipment.
Which of these systems are used depends on the following factors −
 How many devices the microcontroller has to exchange data with?
 How fast the data exchange has to be?
 What is the distance between these devices?
 Is it necessary to send and receive data simultaneously?
One of the most important things concerning serial communication is the Protocol, which should be strictly
observed. It is a set of rules, which must be applied such that the devices can correctly interpret data they
mutually exchange. Fortunately, Arduino automatically takes care of this, so that the work of the
programmer/user is reduced to simple write (data to be sent) and read (received data).
Types of Serial Communications

Serial communication can be further classified as −
 Synchronous − Devices that are synchronized use the same clock and their timing is in synchronization with each other.
 Asynchronous − Devices that are asynchronous have their own clocks and are triggered by the output of the previous state.
It is easy to find out if a device is synchronous or not. If the same clock is given to all the connected devices, then
they are synchronous. If there is no clock line, it is asynchronous.
For example, UART (Universal Asynchronous Receiver Transmitter) module is asynchronous.
The asynchronous serial protocol has a number of built-in rules. These rules are nothing but mechanisms that help
ensure robust and error-free data transfers. These mechanisms, which we get for eschewing the external clock
signal, are −
 Synchronization bits
 Data bits
 Parity bits
 Baud rate
Synchronization Bits
The synchronization bits are two or three special bits transferred with each packet of data. They are the start bit
and the stop bit(s). True to their name, these bits mark the beginning and the end of a packet respectively.
There is always only one start bit, but the number of stop bits is configurable to either one or two (though it is
normally left at one).
The start bit is always indicated by an idle data line going from 1 to 0, while the stop bit(s) will transition back to
the idle state by holding the line at 1.
Data Bits
The amount of data in each packet can be set to any size from 5 to 9 bits. Certainly, the standard data size is your
basic 8-bit byte, but other sizes have their uses. A 7-bit data packet can be more efficient than 8, especially if you
are just transferring 7-bit ASCII characters.
Parity Bits
The user can select whether there should be a parity bit or not, and if yes, whether the parity should be odd or
even. The parity bit is 0 if the number of 1’s among the data bits is even. Odd parity is just the opposite.
Baud Rate
The term baud rate is used to denote the number of bits transferred per second [bps]. Note that it refers to bits, not
bytes. It is usually required by the protocol that each byte is transferred along with several control bits. It means
that one byte in serial data stream may consist of 11 bits. For example, if the baud rate is 300 bps then maximum
37 and minimum 27 bytes may be transferred per second.
Arduino UART
The following code will make Arduino send hello world when it starts up.
void setup() {
Serial.begin(9600); //set up serial library baud rate to 9600
Serial.println("hello world"); //print hello world
void loop() {
After the Arduino sketch has been uploaded to Arduino, open the Serial monitor at the top right section of
Arduino IDE.
Type anything into the top box of the Serial Monitor and press send or enter on your keyboard. This will send a
series of bytes to the Arduino.
The following code returns whatever it receives as an input.
The following code will make Arduino deliver output depending on the input provided.
void setup() {
Serial.begin(9600); //set up serial library baud rate to 9600
void loop() {
if(Serial.available()) //if number of bytes (characters) available for reading from {
serial port
Serial.print("I received:"); //print I received
Serial.write(Serial.read()); //send what you read
Notice that Serial.print and Serial.println will send back the actual ASCII code, whereas Serial.write will send
back the actual text. See ASCII codes for more information.
ARDUINO - INTER INTEGRATED CIRCUIT

Inter-integrated circuit (I2C) is a system for serial data exchange between the microcontrollers and specialized
integrated circuits of a new generation. It is used when the distance between them is short (receiver and
transmitter are usually on the same printed board). Connection is established via two conductors. One is used for
data transfer and the other is used for synchronization (clock signal).
As seen in the following figure, one device is always a master. It performs addressing of one slave chip before the
communication starts. In this way, one microcontroller can communicate with 112 different devices. Baud rate is
usually 100 Kb/sec (standard mode) or 10 Kb/sec (slow baud rate mode). Systems with the baud rate of 3.4
Mb/sec have recently appeared. The distance between devices, which communicate over an I2C bus is limited to
several meters.
Board I2C Pins

The I2C bus consists of two signals − SCL and SDA. SCL is the clock signal, and SDA is the data signal. The
current bus master always generates the clock signal. Some slave devices may force the clock low at times to
delay the master sending more data (or to require more time to prepare data before the master attempts to clock it
out). This is known as “clock stretching”.
Following are the pins for different Arduino boards −
 Uno, Pro Mini A4 (SDA), A5 (SCL)
 Mega, Due 20 (SDA), 21 (SCL)
 Leonardo, Yun 2 (SDA), 3 (SCL)

Arduino I2C
We have two modes - master code and slave code - to connect two Arduino boards using I2C. They are −
 Master Transmitter / Slave Receiver
 Master Receiver / Slave Transmitter
Master Transmitter / Slave Receiver

Let us now see what is master transmitter and slave receiver.
Master Transmitter
The following functions are used to initialize the Wire library and join the I2C bus as a master or slave. This is
normally called only once.
 Wire.begin(address) − Address is the 7-bit slave address in our case as the master is not specified and it will join the bus as a master.
 Wire.beginTransmission(address) − Begin a transmission to the I2C slave device with the given address.
 Wire.write(value) − Queues bytes for transmission from a master to slave device (in-between calls to beginTransmission() and
endTransmission()).
 Wire.endTransmission() − Ends a transmission to a slave device that was begun by beginTransmission() and transmits the bytes that
were queued by wire.write().
Example
#include <Wire.h> //include wire library
void setup() //this will run only once {
Wire.begin(); // join i2c bus as master
short age = 0;
void loop() {
Wire.beginTransmission(2);
// transmit to device #2
Wire.write("age is = ");
Wire.write(age); // sends one byte
Wire.endTransmission(); // stop transmitting
delay(1000);
Slave Receiver
The following functions are used −
 Wire.begin(address) − Address is the 7-bit slave address.
 Wire.onReceive(received data handler) − Function to be called when a slave device receives data from the master.
 Wire.available() − Returns the number of bytes available for retrieval with Wire.read().This should be called inside the
Wire.onReceive() handler.
Example
#include <Wire.h> //include wire library
void setup() { //this will run only once
Wire.begin(2); // join i2c bus with address #2
Wire.onReceive(receiveEvent); // call receiveEvent when the master send any thing
Serial.begin(9600); // start serial for output to print what we receive
void loop() {
delay(250);
//-----this function will execute whenever data is received from master-----//
void receiveEvent(int howMany) {
while (Wire.available()>1) // loop through all but the last {
char c = Wire.read(); // receive byte as a character
Serial.print(c); // print the character
Master Receiver / Slave Transmitter

Let us now see what is master receiver and slave transmitter.
Master Receiver
The Master, is programmed to request, and then read bytes of data that are sent from the uniquely addressed Slave
Arduino.
The following function is used −
Wire.requestFrom(address,number of bytes) − Used by the master to request bytes from a slave device. The
bytes may then be retrieved with the functions wire.available() and wire.read() functions.
Example
#include <Wire.h> //include wire library void setup() {
Wire.begin(); // join i2c bus (address optional for master)
Serial.begin(9600); // start serial for output
}
void loop() {
Wire.requestFrom(2, 1); // request 1 bytes from slave device #2
while (Wire.available()) // slave may send less than requested {
char c = Wire.read(); // receive a byte as character
Serial.print(c); // print the character
delay(500);
Slave Transmitter
The following function is used.
Wire.onRequest(handler) − A function is called when a master requests data from this slave device.
Example
#include <Wire.h>
void setup() {
Wire.begin(2); // join i2c bus with address #2
Wire.onRequest(requestEvent); // register event
Byte x = 0;
void loop() {
delay(100);
// function that executes whenever data is requested by master
// this function is registered as an event, see setup()
void requestEvent() {
Wire.write(x); // respond with message of 1 bytes as expected by master
x++;
ARDUINO - SERIAL PERIPHERAL INTERFACE

A Serial Peripheral Interface (SPI) bus is a system for serial communication, which uses up to four conductors,
commonly three. One conductor is used for data receiving, one for data sending, one for synchronization and one
alternatively for selecting a device to communicate with. It is a full duplex connection, which means that the data
is sent and received simultaneously. The maximum baud rate is higher than that in the I2C communication
system.
Board SPI Pins
SPI uses the following four wires −
 SCK − This is the serial clock driven by the master.
 MOSI − This is the master output / slave input driven by the master.
 MISO − This is the master input / slave output driven by the master.
 SS − This is the slave-selection wire.
The following functions are used. You have to include the SPI.h.
 SPI.begin() − Initializes the SPI bus by setting SCK, MOSI, and SS to outputs, pulling SCK and MOSI low, and SS high.
 SPI.setClockDivider(divider) − To set the SPI clock divider relative to the system clock. On AVR based boards, the dividers
available are 2, 4, 8, 16, 32, 64 or 128. The default setting is SPI_CLOCK_DIV4, which sets the SPI clock to one-quarter of the
frequency of the system clock (5 Mhz for the boards at 20 MHz).
 Divider − It could be (SPI_CLOCK_DIV2, SPI_CLOCK_DIV4, SPI_CLOCK_DIV8, SPI_CLOCK_DIV16, SPI_CLOCK_DIV32,

SPI_CLOCK_DIV64, SPI_CLOCK_DIV128).
 SPI.transfer(val) − SPI transfer is based on a simultaneous send and receive: the received data is returned in receivedVal.
 SPI.beginTransaction(SPISettings(speedMaximum, dataOrder, dataMode)) − speedMaximum is the clock,

dataOrder(MSBFIRST or LSBFIRST), dataMode(SPI_MODE0, SPI_MODE1, SPI_MODE2, or SPI_MODE3).
We have four modes of operation in SPI as follows −
 Mode 0 (the default) − Clock is normally low (CPOL = 0), and the data is sampled on the transition from low to high (leading edge)
(CPHA = 0).
 Mode 1 − Clock is normally low (CPOL = 0), and the data is sampled on the transition from high to low (trailing edge) (CPHA = 1).
 Mode 2 − Clock is normally high (CPOL = 1), and the data is sampled on the transition from high to low (leading edge) (CPHA = 0).
 Mode 3 − Clock is normally high (CPOL = 1), and the data is sampled on the transition from low to high (trailing edge) (CPHA = 1).
 SPI.attachInterrupt(handler) − Function to be called when a slave device receives data from the master.
Now, we will connect two Arduino UNO boards together; one as a master and the other as a slave.
 (SS) : pin 10
 (MOSI) : pin 11
 (MISO) : pin 12
 (SCK) : pin 13
The ground is common. Following is the diagrammatic representation of the connection between both the boards
−
Let us see examples of SPI as Master and SPI as Slave.
SPI as MASTER
Example
#include <SPI.h>
void setup (void) {
Serial.begin(115200); //set baud rate to 115200 for usart
digitalWrite(SS, HIGH); // disable Slave Select
SPI.begin ();
SPI.setClockDivider(SPI_CLOCK_DIV8);//divide the clock by 8
void loop (void) {
char c;
digitalWrite(SS, LOW); // enable Slave Select
// send test string
for (const char * p = "Hello, world!\r" ; c = *p; p++) {
SPI.transfer (c);
Serial.print(c);
digitalWrite(SS, HIGH); // disable Slave Select
delay(2000);
SPI as SLAVE
Example
#include <SPI.h>
char buff [50];
volatile byte indx;
volatile boolean process;
void setup (void) {
pinMode(MISO, OUTPUT); // have to send on master in so it set as output
SPCR |= _BV(SPE); // turn on SPI in slave mode
indx = 0; // buffer empty
process = false;
SPI.attachInterrupt(); // turn on interrupt
ISR (SPI_STC_vect) // SPI interrupt routine {
byte c = SPDR; // read byte from SPI Data Register
if (indx < sizeof buff) {
buff [indx++] = c; // save data in the next index in the array buff
if (c == '\r') //check for the end of the word
process = true;
void loop (void) {
if (process) {
process = false; //reset the process
Serial.println (buff); //print the array on serial monitor
indx= 0; //reset button to zero

Arduino Quick Guide123

Uploaded by

Arduino Quick Guide123

Uploaded by

ARDUINO QUICK GUIDE

The key features are

3. To load a new code onto the board, use a USB cable.

Board Name Operating Clock Digital Analog PWM UART Programming

ARDUINO BOARD DESCRIPTION

(6,7,8,9) Pins (3.3, 5, GND, Vin)

A − Used to check if there is any compilation error.

ARDUINO VARIABLES & CONSTANTS

 Inside a function or a block, which is called local variables.

int z ; Local variable declaration

float c = 0 ; Global variable declaration

int z ; Local variable declaration

assignment Stores the value to the right of the equal sign in

Modulus Operator and remainder of after an B % A will

Comparison Operators: Assume variable A holds 10 and variable B holds 20 then

Checks if the value of two operands is equal or not, if (A == B) is

Checks if the value of two operands is equal or not, if (A != B) is

Checks if the value of left operand is less than the

Checks if the value of left operand is greater than the

Checks if the value of left operand is less than or equal

greater than or (A >= B) is

Boolean Operators: Assume variable A holds 10 and variable B holds 20 then

Called Logical AND operator. If both the operands are (A && B) is

Called Logical OR Operator. If any of the two operands is (A || B) is

Called Logical NOT Operator. Use to reverses the logical

Bitwise Operators: Assume variable A holds 60 and variable B holds 13 then

(A & B) will give

Binary OR Operator copies a bit if it exists in (A | B) will give 61

Binary XOR Operator copies the bit if it is set in (A ^ B) will give 49

Binary Right Shift Operator. The left operands

Compound Operators: Assume variable A holds 10 and variable B holds 20 then

Increment operator, increases integer value by

decrement -- A-- will give 9

Add AND assignment operator. It adds right B += A is

Subtract AND assignment operator. It subtracts B -= A is

Multiply AND assignment operator. It B*= A is

Divide AND assignment operator. It divides B /= A is

Modulus AND assignment operator. It takes B %= A is

compound A &= 2 is same as

ARDUINO CONTROL STATEMENTS

S.NO. Control Statement & Description

1 It takes an expression in parenthesis and a statement or block of statements. If the expression

If…else if …else statement

switch case statement

S.NO. Loop & Description

 Function return type

return z; // return the value

Statements // group of statements

result = Sum_func (5,6) ; // function call

 Function return type

int sum_func (int , int ) ; // function prototype

Statements // group of statements

result = Sum_func (5,6) ; // function call

int sum_func (int x, int y) // function declaration {

return z; // return the value

char my_str[6]; // an array big enough for a 5 character string

my_str[0] = 'H'; // the string consists of 5 characters

my_str[5] = 0; // 6th array element is a null terminator

char my_str[] = "Hello";

Manipulating String Arrays

char like[] = "I like coffee and cake"; // create a string

// (1) print the string

// (3) substitute a word into the string

like[13] = ' '; // replace the null terminator with a space

like[18] = 't'; // insert the new word

like[21] = 0; // terminate the string

The sketch works in the following way.

Creating and Printing the String

Shortening the String

Changing a Word in the String

Functions to Manipulate String Arrays

char str[] = "This is my string"; // create a string

char out_str[40]; // output from string functions placed here

// (1) print the string

// (2) get the length of the string (excludes null terminator)

Serial.print("String length is: ");