DEVELOPMENT OF SCALABLE AND OPEN SOURCE

CODE FOR COMPACT AERIAL SYSTEM

Minor Project Report

Submitted in partial fulfillment of the requirement

For the award of the degree of

BACHELOR OF TECHNOLOGY
in
MECHANICAL AND AUTOMATION ENGINEERING

Submitted By
Shubham (06614803616)

Shubham Sharma (07014803616)

Abhishek Sharma (35114803616)

Under the Guidance of

Ms. SURABHI LATA

Department of Mechanical and Automation Engineering

Maharaja Agrasen Institute Of Technology, New Delhi

 CERTIFICATE

This is to certify that the report entitled “Development of Scalable and Open Source Code For
Compact Aerial System” submitted by Shubham (06614803616), Shubham
Sharma(07014803616), Abhishek Sharma (35114803616),in partial fulfillment for the
award of Bachelor of Technology in Mechanical and Automation Engineering from
Maharaja Agrasen Institute of Technology, is a record of bona fide project work carried out
by them under my supervision and guidance.
To the best of my knowledge the result contained in this thesis have not been submitted in part or
full to any other university for the award of any other degree or diploma.

Ms. Surabhi Lata

Department of Mechanical and Automation Engineering
Maharaja Agrasen Institute of Technology, Rohini
 ACKNOWLEDGEMENT

It gives us immense pleasure to express our deepest sense of gratitude and sincere thanks to
our highly respected and esteemed guide Ms. Surabhi Lata (Lecturer MAE), MAIT Rohini,
for their valuable guidance, encouragement and help for completing this work. Their useful
suggestions for this whole work and co-operative behaviour are sincerely acknowledged.

We deeply express our sincere thanks to our Head of Department Dr. V.N. Mathur for
encouraging and allowing us to present the project on the topic “DEVELOPMENT OF OPEN
SORCE AND SCALABLE AND OPEN SORCE CODE FOR COMPACT AERIAL
SYSTEM” at our department premises for the partial fulfilment of the requirements leading
to the award of B-Tech degree.

We are also highly thankful to our project internal evaluator and guide Dr. O.P Grover (Prof.
MAE), MAIT Rohini, whose invaluable guidance helped us understand the project better.

Lastly, we would like to express our deep apperception towards our classmates and our
indebtedness to our parents for providing us the moral support and encouragement.

SHUBHAM (06614803616)

SHUBHAM SHARMA (07014803616)

ABHISHEK SHARMA (35114803616)

 ABSTRACT

In today’s world where technology is taking control over almost all walks of life, growth in
defence sector, growth in automobiles sector, growth in industrial sector which had led to sound
pollution, traffic jam and air pollution. Quadcopter is one of flying unit used to lift the object
from one place to another in lesser time or can be used for surveillance purpose, industrial
purpose. As the technology has matured and become more mainstream, a number of practical
and very interesting uses of Quadcopter technology have emerged.

Arduino is an open source electronic platform based on easy to use hardware and software.
Arduino boards are able to read inputs – Light on a sensor, a finger on a button, o a twitter
message – and turn it into an output – activating a motor, turning on an LED publishing
something online. You can tell your board what to do by sending a set of instruction to the
microcontroller on the board. To do so you use the Arduino programming language (based on
Wiring) and the Arduino software (IDE) based on processing.

At industry level applications, quadcopter is made using KK board module which comes with
preprogrammed KK board and balanced gyroscope module which is not economical for smaller
applications. It’s not a cost-effective method. Our objective is making the quadcopter
economical and efficient for small level applications this work is proposed, to design and
develop a quadcopter using Arduino Uno board instead of preprogrammed KK flight Controller
board. It has wide application like quadcopter mounted with camera and GPS tracker could be
used for surveillance of wide areas such as forest and coast guard applications etc.

This project wok includes learning, discussing, coding and conducting experiment for each and
every peripheral in in-depth and step by step manner and developing and efficient and effective
code which is open source and scalable i.e. flexible for any editing and updating by third party in
future for Arduino Uno completely from scratch using the hardware required in quadcopter.

KEY WORDS: Embedded C, Quadcopter, Arduino Uno, Scalable Code

 TABLE OF CONTENT
TOPIC

CERTIFICATE

ACKNOWLEGMENT

ABSTRACT

TABLE OF CONTENT

LIST OF FIGURES

LIST OF TABLES

CHAPTER 1
INTRODUCTION

1.1 QUADCOPTER: AN INTRODUCTION 1

1.2 INTRODUCTION TO ARDUINO 1

1.3 ADVANTAGES OF ARDUINO 2

1.4 PROBLEM DEFINITION 3

1.5 PLAN OF INVESTIGATION 4

CHAPTER 2
FLIGHT DYNAMICS AND DEVELOPMENTS

2.1 UAV QUADCOPTER 5

2.1.1 WORKING OF QUADCOPTER 5

2.1.2 FLIGHT CONTROL 5

2.2 ADVANTAGE OF QUADCOPTER 6

2.3 TIMELINE OF QUADCOPTER 7

 CHAPTER 3
OVERVIEW OF PROJECT

3.1 BLOCK DIAGRAM OF QUADCOPTER 9

3.2 CIRCUIT DIAGRAM 10

3.2.1 COMPONENTS DESCRIPTION ARDUINO MICROCONTROLLER 10

3.2.2 PHYSICAL COMPONENTS 13

3.3 FLOW CHARTS OF CODES 16

3.4 CODES 20

3.4.1 PROGRAM TO CONTROL BLDC OR SERVO MOTORS 20

3.4.2 PROGRAM TO CONTROL DC MOTORS 21

3.4.3 SIMPLE BLINKING LED 22

3.4.4 MULTIPLE LED IN SEQUENCE 23

CHAPTER 4
INTERFACE

4.1 INTRODUCTION TO INTERFACING 25

4.2 ADVANTAGES OF EMBEDDED SYSTEMS 25
4.3 CODE OF INTERFACING 26

CHAPTER 5
RESULTS AND FUTURE SCOPE

5.1 RESULTS OF DISCUSSION 46

5.2 FUTURE SCOPE OF STUDY 46

REFERENCES 47
List of Figures

Figure 2.1 Roll, pitch, Yaw of a quadcopter

Figure 2.2 Quadcopter: Motor rotation directions

Figure 3.1 Block diagram of quadcopter
Figure 3.2 Circuit diagram of quadcopter
Figure 3.3 Arduino UNO microcontroller
Figure 3.4 MPU-6050 (Triple axis gyroscope & accelerometer)
Figure Figure 3.5 HMC5883L Magnetometer
Figure 3.6 BME280 Pressure, temperature & humidity

Figure 3.7 Node MCU Esp8266 Wi-Fi module

Figure 3.8 frame

Figure 3.9 BP A2217-9 electric brushless motor.

Figure 3.10 30A Hobby wing Fly fun brushless ESC.

Figure 5.1 Server Client Concept

List of Tables

Table 1.1 Arduino Uno Technical Specification

 CHAPTER 1
INTRODUCTION

1.1 QUADCOPTER: AN INTRODUCTION

In this modern age of technology, quadcopter has become one of the most popular inventions
in the field of science. A quadcopter, also known as UAV (Unmanned Aerial Vehicle) uses
four propellers for lift and stabilization. The rotors are directed upwards and they are placed
in a square formation with equal distance from the center of mass of the quadcopter. The
quadcopter is controlled by adjusting the angular velocities of the rotors which are spun by
electric motors. Now a-days, quadcopters have received considerable attention from
researchers as the complex phenomena of the quadcopter has generated several areas of
interest. [1] The basic concept of flight mechanism is as follows:
a) YAW (turning left and right) is controlled by turning up the speed of the
regular rotating motors and taking away power from the counter rotating; by taking
away the same amount that you put in on the regular rotors produces
no extra lift (it won’t go higher) but since the counter torque is now less, the quadcopter
rotates.

b) ROLL (tilting left and right) is controlled by increasing speed on one motor and
lowering on the opposite one.

c) PITCH (moving up and down, similar to nodding) is controlled the same way as roll but
using the second set of motors. This may be confusing but roll and pitch are determined from
where the “front” of the drone is. To roll or pitch, one rotor’s thrust is decreased and the
opposite rotor’s thrust is increased by the same amount. This causes the quadcopter to tilt.
When the quadcopter tilts, the force vector is split into a horizontal component and a vertical
component. [1-2]
Various groups such as the military, engineers, researchers, and hobbyists have been
developing quadcopters to understand different technical areas. For example, quadcopters can
be used for reconnaissance and collecting data. This could range from searching for survival
victims in a disaster area to checking the state of electrical power lines. Some quadcopters in
production today can hold light payloads, such as food and medical supplies, and deliver them
to areas where normal planes can not reach [4]. Many amateur radio operators have designed
and built their own multi-copters. Universities, such as MIT, have been studying and doing
research for the quadcopter over the past couple of years [5]. This would be a great
opportunity for students of the University of Manitoba to join this area of study.

1.2 INTRODUCTION TO ARDUINO

Arduino is an open-source electronics platform based on easy-to-use hardware and
software. Arduino boards are able to read inputs - light on a sensor, a finger on a button, or a
Twitter message - and turn it into an output - activating a motor, turning on an LED,
publishing something online. You can tell your board what to do by sending a set of
instructions to the microcontroller on the board. To do so you use the Arduino programming
language (based on Wiring), and the Arduino Software (IDE) based on processing.
Over the years Arduino has been the brain of thousands of projects, from everyday objects to
complex scientific instruments. A worldwide community of makers - students, hobbyists,
artists, programmers, and professionals - has gathered around this open-source platform, their
contributions have added up to an incredible amount of accessible knowledge that can be of
great help to novices and experts alike.

Arduino was born at the Ivrea Interaction Design Institute as an easy tool for fast prototyping,
aimed at students without a background in electronics and programming. As soon as it
reached a wider community, the Arduino board started changing to adapt to new needs and
challenges, differentiating its offer from simple 8-bit boards to products for IoT applications,
wearable, 3D printing, and embedded environments. All Arduino boards are completely
open-source, empowering users to build them independently and eventually adapt them to
their particular needs. The software too, is open-source, and it is growing through the
contributions of users worldwide.

1.3 ADVANTAGES OF ARDUINO

Thanks to its simple and accessible user experience, Arduino has been used in thousands of
different projects and applications. The Arduino software is easy-to-use for beginners, yet
flexible enough for advanced users. It runs on Mac, Windows, and Linux. Teachers and
students use it to build low cost scientific instruments, to prove chemistry and physics
principles, or to get started with programming and robotics. Designers and architects build
interactive prototypes, musicians and artists use it for installations and to experiment with
new musical instruments. Makers, of course, use it to build many of the projects exhibited at
the Maker Faire, for example. Arduino is a key tool to learn new things. Anyone - children,
hobbyists, artists, programmers - can start tinkering just following the step by step
instructions of a kit, or sharing ideas online with other members of the Arduino community.

There are many other microcontrollers and microcontroller platforms available for physical
computing. Parallax Basic Stamp, Netmedia's BX-24, Phidgets, MIT's Handyboard, and
many others offer similar functionality. All of these tools take the messy details of
microcontroller programming and wrap it up in an easy-to-use package. Arduino also
simplifies the process of working with microcontrollers, but it offers some advantage for
teachers, students, and interested amateurs over other systems:

a) Inexpensive - Arduino boards are relatively inexpensive compared to other

microcontroller platforms. The least expensive version of the Arduino module can be
assembled by hand, and even the pre-assembled Arduino modules cost less than $50
b) Cross-platform - The Arduino Software (IDE) runs on Windows, Macintosh OSX,
and Linux operating systems. Most microcontroller systems are limited to Windows.
c) Simple, clear programming environment - The Arduino Software (IDE) is easy-to-use
for beginners, yet flexible enough for advanced users to take advantage of as well. For
teachers, it's conveniently based on the Processing programming environment, so
students learning to program in that environment will be familiar with how the Arduino
IDE works.
d) Open source and extensible software - The Arduino software is published as open
source tools, available for extension by experienced programmers. The language can be
expanded through C++ libraries, and people wanting to understand the technical details
can make the
2
 leap from Arduino to the AVR C programming language on which it's based.
Similarly, you can add AVR-C code directly into your Arduino programs if
you want to.
e) Open source and extensible hardware - The plans of the Arduino boards
are published under a Creative Commons license, so experienced circuit
designers can make their own version of the module, extending it and
improving it. Even relatively inexperienced users can build the breadboard
version of the module in order to understand how it works and save money.

Table 2.1 Arduino Uno Technical Specification

Microcontroller ATmega328p – 8 bit AVR family microcontroller

Operating Voltage 5V

Recommended Input Voltage 7-12V

Input Voltage Limits 6-20V

Analog Input Pins 6 (A0 – A5)

Digital I/O Pins 14 (Out of which 6 provide PWM output)

DC Current on I/O Pins 40 mA

DC Current on 3.3V Pin 50 Ma

Flash Memory 32 KB (0.5 KB is used for Bootloader)

SRAM 2 KB

EEPROM 1 KB

Frequency (Clock Speed) 16 MHz

1.4 PROBLEM DEFINITION

The main objective of our project is to make a quad copter which could be used in rescue missions
as well as in package delivering operations. The quadcopter will be controlled by an Arduino
microcontroller which will be program flexible according to the user. The flight will be made stable
with the accumulation of various sensors like the gyroscope, accelerometer and
magnetometer.Additionally, a GPS module, a camera and infrared sensors will be attached to
increase its performance. The GPS module would give the coordinates of the quadcopter to where it
will be flying and the camera would provide live streaming of the area back to the ground
controller. The quadcopter is estimated to give a flight time of nearly 6 minutes. The quadcopter
will be controlled using Wi-Fi instead of a radio controller to increase its range.
3
1.5 PLAN OF INVESTIGATION

STEP1:Selection of project topic .

STEP2:Study of the project topic .

STEP3: Study of embedded C ,learning about library files and syntax.

STEP4: Study of previous work done related to our project.

STEP5: Learnt to work on Arduino IDE .

STEP6: Started with short programs on Arduino related to LED.

STEP7: Started working on complex programs related to speed modulation of DC motors.

STEP8: Stated working on programs to modulate motors used in our project.

STEP9: Studied how interfacing works in Arduino.

STEP10: Tried basic interfacing programs , to interface multiple motors.

STEP11: Working on program to synchronize the motors to make our device fly.

4
 CHAPTER 2
FLIGHT DYNAMICS AND DEVELOPMENTS

2.1 UAV QUADCOPTER

2.1.1WORKING OF QUADCOPTER

A quadcopter is operated by varying spin RPM of its four rotors to control lift and torque.
The thrust is determined using altitude, pitch, and roll angles and is obtained from the ratio of
the angles. The thrust plays a key role in maneuvering, enables the user to perform flying
routine which includes aerial maneuvers. To conduct such maneuvers precise angle handling
is required. It serves as a solution to handle the copter with angular precision which illustrates
how the spin of four rotors is varied simultaneously to achieve angular orientation along with
takeoff, landing and hovering at an altitude. [1]

Figure 2.1. Roll, pitch, Yaw of a quadcopter

A UAV quadcopter is an unmanned aerial vehicle with four rotating rotors used for lift and
movement. It uses an electronic control system and electronic sensors to help stabilize itself.
Quadcopter parts have been decreasing in price over the past couple of years due to
technological advances. As a result more hobbyists, universities, and industries are taking
advantage of this opportunity to design and develop applications for the quadcopter.
2.1.2 FLIGHT CONTROL
A quadcopter consists of four motors evenly distributed along the quadcopter frame as can
be seen in figure 1. The circles represent the spinning rotors of the quadcopter and the arrows
represent the rotation direction. Motors one and three rotate in a clockwise direction using
pusher rotors. Motor two and four rotate in a counter-clockwise direction using puller rotors.
Each motor produces a thrust and torque about the center of the quadcopter. Due to the
opposite spinning directions of the motors, the net torque about the center of the quadcopter
is ideally zero, producing zero angular acceleration. This eliminates the need for yaw
5
stabilization. A vertical force is created by increasing the speed of all the motors by the same
amount of throttle. As the vertical forces overcome the gravitational forces of the earth, the
quadcopter begins to rise in altitude. Figure 1 shows the vertical movement of the quadcopter.
As above, the circles represent the spinning rotors, the larger arrows represent the direction
the rotors are spinning, and the black arrows represent the forces caused by the spinning
rotors. Pitch is provided by increasing (or decreasing) the speed of the front or rear motors.
This causes the quadcopter to turn along the x axis. The overall vertical thrust is the same as
hovering due to the left and right motors; hence only pitch angle acceleration is changed.
Figure 1 shows an example of pitch movement of a quadcopter. As the front motor slows
down, the forces created by the corresponding rotor are less then the forces created by the
back rotor. These forces are represented by the blue arrows. These forces cause the
quadcopter to tip forward and this movement is represented by the red arrow Roll is provided
by increasing (or decreasing) the speed of the left rotor speed and right motors. This causes
the quadcopter to turn along the y axis. The overall vertical thrust is the same as hovering due
to the front and back motors; hence only roll angle acceleration is changed. Figure 2.4 shows
an example of roll movement of a quadcopter. As the right motor slows down, the forces
created by the corresponding rotor are less then the forces created by the left rotor. These
forces are represented by the blue arrows. This causes the quadcopter to tip to the right and
this movement is represented by the red arrow. Yaw is provided by increasing (or decreasing)
the speed of the front and rear motors or by increasing (or decreasing) the speed of the left
and right motors. This causes the quadcopter to turn along its vertical axis in the direction of
the stronger spinning rotors. Figure 2 shows an

Figure 2.2 : Quadcopter: Motor rotation directions

2.2 ADVANTAGES OF QUADCOPTER

There are many advantages to quadcopters compared to other aircrafts. A quadcopter does
not require a large area to obtain lift, like a fixed wing aircraft does. The quadcopter creates
thrust with four evenly distributed motors along its frame. A helicopter suffers from torque
6
 issue due to its main rotor. The design of the quadcopter does not suffer from the same torque
issues as the helicopter. The counter balancing forces of the spinning motors cancel out the
torque forces caused by each motor causing the quadcopter to balance itself. Because the
quadcopter uses four rotors instead of one main rotor, it requires less kinetic energy per rotor
for the same amount of thrust when compared to the helicopter. Due to this and its
symmetrical design, a quadcopter maintenance and manufacturing costs are relatively lower
then other aircrafts [6]

2.2 TIMELINE OF QUADCOPTER

7
 CHAPTER 3
OVERVIEW OF THE PROJECT

3.1 BLOCK DIAGRAM OF QUADCOPTER

So how does a quadcopter hover or fly in any direction, lift or descend at a moment’s touch on the
remote controller stick. Drones can also fly autonomously through programmed waypoint navigation
software and fly in any direction going from point to point. So, let’s look at the quadcopter technology,
which makes this possible. It is the propeller direction along with the drone’s motor rotation and speed,
which make its flight and maneuverability possible.
The quadcopter’s flight controller sends information to the motors via their electronic speed control
circuits (ESC) information on thrust, RPM, (Revolutions Per Minute) and direction. The flight controller
will also combine IMU, Gyro and GPS data before signaling to the quadcopter motors on thrust and rotor
speed. While the drone and quadcopter technology of today is all modern, they still use the old principles
of aircraft flight, gravity, action and reaction pairs. In the manufacture of quadcopters, propellers and motor
design, the 4 forces which affect all flight (weight, lift, thrust and drag) are also important considerations.
.[25]

Figure 3.1 Block diagram of quadcopter

8
3.2 CIRCUIT DIAGRAM

Figure 3.2 Circuit diagram of quadcopter

a) ARDUINO microcontroller
b) MPU-6050 (3-axis Accelerometer & Gyroscope)
c) HMC-5883L magnetometer
d) BME-280 (temperature, pressure, humidity)
e) 4 no’s of BLDC motors and ESCS
f) GPS module
g) Node MCU ESP8266 (Wi-Fi module)
h) Connecting wires

3.2.1 COMPONENT DESCRIPTION ARDUINO MICROCONTROLLER

Arduino refers to an open-source electronics platform or board and the software used to
program it. Arduino is designed to make electronics more accessible to artists, designers,
hobbyists and anyone interested in creating interactive objects or environments. In our
project, an Arduino UNO microcontroller is used to control the quadcopter flight dynamics.

9
 Figure 3.3. Arduino UNO microcontroller

MPU-6050 (3-AXIS ACCELEROMETER & GYROSCOPE)

The MPU6050 contains both a 3-Axis Gyroscope and a 3-Axis accelerometer allowing
measurements of both independently, but all based around the same axes, thus eliminating the
problems of cross-axis errors when using separate devices.
In our project, we have used the MPU-6050 to help in balancing the flight of the quadcopter
and maintain its flight dynamics.

Figure 3.4. MPU-6050 (Triple axis gyroscope & accelerometer)

3-AXIS MAGNETOMETER(HMC5883L)
The HMC5883L is a triple-axis magnetometer compass, which uses I2C for communication.
This is 5 pin IC. Compass heading accuracy of 1° to 2°, provided by internal 12-bit ADC
(Analog-to-Digital Converter).
In our project, we have used the 3-axis magnetometer to help the quadcopter judge the
direction to where it is going

10
 Figure 3.5. HMC5883L Magnetometer

PRESSURE, HUMIDITY AND TEMPERATURE SENSOR (BME 280)

BME280, the precision sensor from Bosch, is soldered onto PCB. Not only the pressure and
the temperature, this sensor can measure humidity. It uses both I2C and SPI (supports 3-, 4-
wire SPI) interface. In this project, the BME 280 sensor is used to measure the pressure,
humidity and temperature of the area to where the quadcopter is travelling to.

Figure 3.6. BME280 Pressure, temperature & humidity

NODE MCU ESP 8266

MCU ESP8266 is low cost Wi-Fi module with MCU (microcontroller unit) capability. This
small module allows microcontrollers to connect to a Wi-Fi network. It is manufactured by
Espressif system which is a Chinese manufacturer.
In our project we have used this Wi-Fi module to wirelessly communicate with the
quadcopter from the ground station

11
Figure 3.7. Node MCU Esp8266 Wi-Fi module

3.2.2 PHYSICAL COMPONENTS

This subsection describes all the physical components of our project and how they work.

Frame
The frame that made by our designing group is strong and durable. It uses a combination of
carbon fiber plates and aluminum arms for strength and durability. The frame is designed in
such a way that many different configurations could be used, supporting up to eight different
motors in an octocopter configuration. The design is also very modular, in a way that you
could easily add components to the frame by adding an extra carbon plate onto the
quadcopter. The arms are made of regular 5/8 inch hollow square aluminum bars and uses
common nuts and bolts to hold the frame together. Other than the carbon fiber plates,
everything can be found at a local hardware store. This allows easy accessible replacement
parts for replacement or maintenance

Figure 3.8 frame

12
Electric Motors

Figure 3.9: BP A2217-9 electric brushless motor.

The BP A2217-9 electric brushless motor. These motor are shown in figure . These motors
run at maximum efficiency at 15 amperes of current and can handle currents of up to 18
amperes for up to sixty seconds. The maximum revolutions per minute per volt is 950 kpv
and the maximum amount of power the motors can handle is 200 watts. These motors are
also relatively light, weighing about 73.4 grams.
There are two types of motors, brushless and brushed. A basic brushless motor has three
electromagnetic windings separated evenly on the stationary part of the motor, called a stator.
Permanent magnets are located on the rotating part of the motor, called a rotor. The rotor will
begin to rotate when two of the three windings are supplied with a voltage, creating a
magnetic field. The magnetic field created by the windings pushes and pull against the
magnetic field created by the magnets on the rotor. When the magnetic fields are aligned, two
different windings are driven and a new magnetic field is created causing the rotor to
continue to turn. A controller is used to determine the current rotor position relative to the
windings and drive the necessary windings in certain sequence to turn the rotor in the proper
direction. The rotor will turn in the opposite direction if the sequence is reversed.
A brushed motor works in a similar fashion. A brushed motor has the opposite orientation of
brushless motor. The electromagnetic windings are located on the rotor and the magnets are
located on the stator. Like a brushless motor, the rotor on a brushed motor turns due to the
attractive and repulsive forces of the two magnetic fields created by the windings and the
magnets. The main difference between these two motors is that a brushed motor uses a
mechanical switch to change the polarity of the windings to turn the rotor. A brushed motor is
more susceptible to wear and tear because it uses a mechanical mechanism to check and
change the polarity of its windings. It is also limited in speed due to the same reason [8].

13
Electronic Speed Controllers

Figure 3.10: 30A Hobby wing Fly fun brushless ESC.

The Hobbywing FlyFun brushless ESC rated at 30 amperes.These ESC can be seen in figure.
These ESC can push 30 amperes of current continuously, can push currents up to 40
amperes for ten seconds based on voltage output, and handle speeds up to 210,000 rotations
per minute (RPM). One ESC was found to be malfunctioning during testing and extra ESCs
were purchased. We will go into more details about this later in the document.
An electronic speed controller is an electrical circuit that controls the speed of an electric
motor and the direction a motor rotates. A motor turns because of the magnetic forces created
by the windings and the magnets within the motor.
For a brushless motor, the speed of the motor will depend on the frequency of the winding
drive sequence. On a basic brushless motor, there are three windings that are controlled using
pulse width modulated (PWM) signals. Two windings will be driven at a time to create the
necessary magnetic forces to turn the rotor. The greater the frequency sent to the motors, the
faster the rotor will turn due to the magnetic forces. The frequency of the signals is adjusted
by changing the pulse width of the signal. Smaller pulse widths will increase the frequency of
a PWM signal because more pulses can be sent to the windings in the same time duration, and
vice versa for large pulse widths. A brushed ESC works in the same manner but only two
control signals are used.

14
3.3 FLOW CHARTS OF CODES

Flow charts explains the program working any non-coder can understand the working of codes of
Arduino. The following flow charts explain the basic program like blinking of LED , DC motor and
brushless motor.

15
16
17
18
3.4 CODES

3.4.1 PROGRAM TO CONTROL BLDC OR SERVO MOTORS

#include <Servo.h>

Servo ESC; // create servo object to control the ESC

int potValue; // value from the analog pin

void setup() {
// Attach the ESC on pin 9
ESC.attach(9,1000,2000); // (pin, min pulse width, max pulse width in microseconds)
}
void loop() {
potValue = analogRead(A0); // reads the value of the potentiometer (value b/w 0 & 1023)
potValue = map(potValue, 0, 1023, 0, 180); // scale it to use it with the servo library
(value
b/w 0 &180)
ESC.write(potValue); // Send the signal to the ESC
}

19
3.4.2 PROGRAM TO CONTROL DC MOTORS
#define enA 9
#define in1 6
#define in2 7
#define button 4

int rotDirection =
0; int pressed =
false;

void setup() {
pinMode(enA,OUTPUT;
pinMode(in1,OUTPUT);
pinMode(in2,OUTPUT);
pinMode(button, INPUT); // Set initial rotation direction
digitalWrite(in1, LOW);
digitalWrite(in2, HIGH);
}
void loop() {
int potValue = analogRead(A0); // Read potentiometer value
int pwmOutput = map(potValue, 0, 1023, 0 , 255); // Map the potentiometer value from 0
to 255
analogWrite(enA, pwmOutput); // Send PWM signal to L298N Enable pin

// Read button - Debounce

if (digitalRead(button) ==
true) { pressed = !pressed;
}
while (digitalRead(button) == true);
delay(20);
// If button is pressed - change rotation direction
if (pressed == true & rotDirection == 0)
{ digitalWrite(in1, HIGH);
digitalWrite(in2, LOW);
rotDirection = 1;
delay(20);
}
// If button is pressed - change rotation direction
if (pressed == false & rotDirection == 1)
{ digitalWrite(in1, LOW);
digitalWrite(in2, HIGH);
rotDirection = 0;
delay(20);
}
}

20
3.4.3 SIMPLE BLINKING LED
// the setup function runs once when you press reset or power the board

void setup() {

// initialize digital pin LED_BUILTIN as an output.

pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever

void loop() {
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage
level) delay(1000); // wait for a second
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}

21
3.4.4 MULTIPLE LED IN SEQUENCE. (To demonstrate arrays)

int timer = 100; // The higher the number, the slower the timing.
int ledPins[] = { 2, 7, 4, 6, 5, 3}; // an array of pin numbers to which
LEDs are attached
int pinCount = 6; // the number of pins (i.e. the length of the array)

void setup() {
// the array elements are numbered from 0 to (pinCount - 1).
// use a for loop to initialize each pin as an output:
for (int thisPin = 0; thisPin < pinCount;
thisPin++) { pinMode(ledPins[thisPin],
OUTPUT);
}
}

void loop() {
// loop from the lowest pin to the highest:

22
 for (int thisPin = 0; thisPin < pinCount; thisPin++) {
// turn the pin on:
digitalWrite(ledPins[thisPin],
HIGH); delay(timer);
// turn the pin off:
digitalWrite(ledPins[thisPin],
LOW);

// loop from the highest pin to the lowest:

for (int thisPin = pinCount - 1; thisPin >= 0; thisPin--) {
// turn the pin on:
digitalWrite(ledPins[thisPin],
HIGH); delay(timer);
// turn the pin off:
digitalWrite(ledPins[thisPin],
LOW);
}
}

23
 CHAPTER 4
INTERFACE

4.1 INTRODUCTION TO INTERFACING

Embedded system interfacing is the conceptual interface between electrical and computer
engineering—we require the skills of both fields to design good, practical interfaces. I/O is
particularly important to embedded computing systems. Embedded computers are responsible
for a wide range of devices, ranging from simple appliances to complex vehicles and
industrial equipment. This range of I/O requirements calls for a comprehensive playbook of
interfacing techniques. This chapter surveys embedded system interfacing methods and
reviews basic principles of circuit analysis.
A number of interface standards have been developed for computing systems. Many of these
standards are useful for embedded computing. We review the organization of the Open
Systems Interconnection (OSI) and then describe several useful embedded system interface
standards, including I2C, USB, WiFi, Zigbee, Bluetooth, and BLE. We discuss the
implications of Internet-enabled embedded devices that make use of standard interfaces.
Embedded system interfacing often requires us to mix and match components, exposing
incompatibilities. In these cases, an understanding of the circuit characteristics of logic is
essential to ensuring that the logic works as intended. This chapter reviews CMOS logic
characteristics. Logic levels, current drive capability, and timing are critical requirements for
interfacing logic. Design examples include open-collector and high-impedance interfaces and
a shaft encoder.

Embedded System Interfacing: Design for the Internet-of-Things (IoT) and Cyber-Physical
Systems (CPS) takes a comprehensive approach to the interface between embedded systems
and software. It provides the principles needed to understand how digital and analog
interfaces work and how to design new interfaces for specific applications. The presentation
is self-contained and practical, with discussions based on real-world components. Design
examples are used throughout the book to illustrate important concepts. This book is a
complement to the author's Computers as Components, now in its fourth edition, which
concentrates on software running on the CPU, while Embedded System Interfacing explains
the hardware surrounding the CPU.

4.2 ADVANTAGES OF EMBEDDED SYSTEMS

1. Small Size . Since embedded systems are application specific, the custom designed
system will have only necessary components and hence significantly smaller than a
regular computer.
2. Reduced cost. Obviously, since the system has less number of components as com-
pared to a computer.
3. Portability. Small size means portability. A lot of embedded systems we use run
on battery, and can be carried in a pocket. E.g ; calculator, digital watch etc.
4. Low power operation. Most embedded systems require very low power to operate,
thus making them ideal for medical applications.

24
 5. Real time response. Embedded systems are also called real time systems, where
the response to external event has hard boundary for execution. Thus, they are bet-
ter for applications where response to an external event is critical. E.g: Deploying
airbags inside a car after collision.

4.3 CODE OF INTERFACING

Main interfacing program

#include<Wire.h>
#include
<EEPROM.h>

//Declaring Global Variables

byte last_channel_1, last_channel_2, last_channel_3,
last_channel_4; byte lowByte, highByte, type, gyro_address,
error, clockspeed_ok;
byte channel_1_assign, channel_2_assign, channel_3_assign,
channel_4_assign; byte roll_axis, pitch_axis, yaw_axis;
byte receiver_check_byte, gyro_check_byte;
volatile int receiver_input_channel_1, receiver_input_channel_2,
receiver_input_channel_3, receiver_input_channel_4;
int center_channel_1, center_channel_2, center_channel_3,
center_channel_4; int high_channel_1, high_channel_2, high_channel_3,
high_channel_4;
int low_channel_1, low_channel_2, low_channel_3,
low_channel_4; int address, cal_int;
unsigned long timer, timer_1, timer_2, timer_3, timer_4,
current_time; float gyro_pitch, gyro_roll, gyro_yaw;
float gyro_roll_cal, gyro_pitch_cal, gyro_yaw_cal;

//Setup routine
void setup(){
pinMode(12, OUTPUT);
//Arduino (Atmega) pins default to inputs, so they don't need to be explicitly declared as
inputs
PCICR |= (1 << PCIE0); // set PCIE0 to enable PCMSK0 scan
PCMSK0 |= (1 << PCINT0); // set PCINT0 (digital input 8) to trigger an interrupt on state
change
PCMSK0 |= (1 << PCINT1); // set PCINT1 (digital input 9)to trigger an interrupt on state
change
PCMSK0 |= (1 << PCINT2); // set PCINT2 (digital input 10)to trigger an interrupt on state
change
25
 PCMSK0 |= (1 << PCINT3); // set PCINT3 (digital input 11)to trigger an interrupt on state
change

Wire.begin(); //Start the I2C as master

Serial.begin(57600); //Start the serial connetion @ 57600bps
delay(250); //Give the gyro time to start
}
//Main program
void loop(){
//Show the YMFC-3D V2 intro
intro();

Serial.println(F(""));
Serial.println(F("==================================================="));
Serial.println(F("System
check")); delay(1000);
Serial.println(F("Checking I2C clock speed."));
delay(1000);

TWBR = 12; //Set the I2C clock speed to 400kHz.

#if F_CPU == 16000000L //If the clock speed is 16MHz include the next code line
when compiling
clockspeed_ok = 1; //Set clockspeed_ok to 1
#endif //End of if statement

if(TWBR == 12 && clockspeed_ok){

Serial.println(F("I2C clock speed is correctly set to 400kHz."));
}
else{
Serial.println(F("I2C clock speed is not set to 400kHz. (ERROR
8)")); error = 1;
}

if(error == 0){
Serial.println(F(""
));

Serial.println(F("==================================================="));
Serial.println(F("Transmitter setup"));

Serial.println(F("==================================================="));
delay(1000);
Serial.print(F("Checking for valid receiver signals."));
//Wait 10 seconds until all receiver inputs are valid
wait_for_receiver();
Serial.println(F(""));
}
//Quit the program in case of an
error if(error == 0){
delay(2000);
26
 Serial.println(F("Place all sticks and subtrims in the center position within 10
seconds.")); for(int i = 9;i > 0;i--){
delay(1000);
Serial.print(i);
Serial.print(" ");
}
Serial.println(" ");
//Store the central stick positions
center_channel_1 =
receiver_input_channel_1;
center_channel_2 =
receiver_input_channel_2;
center_channel_3 =
receiver_input_channel_3;
center_channel_4 =
receiver_input_channel_4;
Serial.println(F(""));
Serial.println(F("Center positions
stored.")); Serial.print(F("Digital input
08 = "));
Serial.println(receiver_input_channel_1)
; Serial.print(F("Digital input 09 = "));
Serial.println(receiver_input_channel_2)
; Serial.print(F("Digital input 10 = "));
Serial.println(receiver_input_channel_3)
; Serial.print(F("Digital input 11 = "));
Serial.println(receiver_input_channel_4)
; Serial.println(F(""));
Serial.println(F(""));
}
if(error == 0){
Serial.println(F("Move the throttle stick to full throttle and back to center"));
//Check for throttle movement
check_receiver_inputs(1);
Serial.print(F("Throttle is connected to digital input
")); Serial.println((channel_3_assign &
0b00000111) + 7);
if(channel_3_assign & 0b10000000)Serial.println(F("Channel inverted =
yes")); else Serial.println(F("Channel inverted = no"));
wait_sticks_zero();

Serial.println(F(""));
Serial.println(F(""));
Serial.println(F("Move the roll stick to simulate left wing up and back to center"));
//Check for throttle movement
check_receiver_inputs(2);
Serial.print(F("Rollis connected to digital input"));
Serial.println((channel_1_assign & 0b00000111) +
7);
if(channel_1_assign & 0b10000000)Serial.println(F("Channel inverted =
yes")); else Serial.println(F("Channel inverted = no"));
27
 wait_sticks_zero();
}
if(error == 0){
Serial.println(F(""));
Serial.println(F(""));
Serial.println(F("Move the pitch stick to simulate nose up and back to center"));
//Check for throttle movement
check_receiver_inputs(3);
Serial.print(F("Pitch is connected to digital input "));
Serial.println((channel_2_assign & 0b00000111) + 7);
if(channel_2_assign & 0b10000000)Serial.println(F("Channel inverted =
yes")); else Serial.println(F("Channel inverted = no"));
wait_sticks_zero();
}
if(error == 0){
Serial.println(F(""));
Serial.println(F(""));
Serial.println(F("Move the yaw stick to simulate nose right and back to center"));
//Check for throttle movement
check_receiver_inputs(4);
Serial.print(F("Yaw is connected to digital input
")); Serial.println((channel_4_assign &
0b00000111) + 7);
if(channel_4_assign & 0b10000000)Serial.println(F("Channel inverted =
yes")); else Serial.println(F("Channel inverted = no"));
wait_sticks_zero();
}
if(error == 0){
Serial.println(F(""));
Serial.println(F(""));
Serial.println(F("Gently move all the sticks simultaneously to their
extends")); Serial.println(F("When ready put the sticks back in their
center positions"));
//Register the min and max values of the receiver channels
register_min_max();
Serial.println(F(""));
Serial.println(F(""));
Serial.println(F("High, low and center values found during
setup")); Serial.print(F("Digital input 08 values:"));
Serial.print(low_channel_1);
Serial.print(F(" - "));
Serial.print(center_channel_1);
Serial.print(F(" - "));
Serial.println(high_channel_1);
Serial.print(F("Digital input 09
values:")); Serial.print(low_channel_2);
Serial.print(F(" - "));
Serial.print(center_channel_2);
Serial.print(F(" - "));
Serial.println(high_channel_2);
Serial.print(F("Digital input 10
28
 values:")); Serial.print(low_channel_3);
Serial.print(F(" - "));
Serial.print(center_channel_3);
Serial.print(F(" - "));
Serial.println(high_channel_3);
Serial.print(F("Digital input 11
values:")); Serial.print(low_channel_4);
Serial.print(F(" - "));
Serial.print(center_channel_4);
Serial.print(F(" - "));

Serial.println(high_channel_4);
Serial.println(F("Move stick 'nose up' and back to center to continue"));
check_to_continue();
}

if(error == 0){
//What gyro is
connected
Serial.println(F(""));

Serial.println(F("==================================================="));
Serial.println(F("Gyro search"));

Serial.println(F("==================================================="));
delay(2000);

Serial.println(F("Searching for MPU-6050 on address

0x68/104")); delay(1000);
if(search_gyro(0x68, 0x75) == 0x68){
Serial.println(F("MPU-6050 found on address
0x68")); type = 1;
gyro_address = 0x68;
}

if(type == 0){
Serial.println(F("Searching for MPU-6050 on address
0x69/105")); delay(1000);
if(search_gyro(0x69, 0x75) == 0x68){
Serial.println(F("MPU-6050 found on address
0x69")); type = 1;
gyro_address = 0x69;
}
}

if(type == 0){
Serial.println(F("Searching for L3G4200D on address
0x68/104")); delay(1000);
if(search_gyro(0x68, 0x0F) == 0xD3){
Serial.println(F("L3G4200D found on address
0x68")); type = 2;
29
 gyro_address = 0x68;
}
}

if(type == 0){
Serial.println(F("Searching for L3G4200D on address
0x69/105")); delay(1000);
if(search_gyro(0x69, 0x0F) == 0xD3){
Serial.println(F("L3G4200D found on address
0x69")); type = 2;
gyro_address = 0x69;

}
}

if(type == 0){
Serial.println(F("Searching for L3GD20H on address
0x6A/106")); delay(1000);
if(search_gyro(0x6A, 0x0F) == 0xD7){
Serial.println(F("L3GD20H found on address
0x6A")); type = 3;
gyro_address = 0x6A;
}
}

if(type == 0){
Serial.println(F("Searching for L3GD20H on address
0x6B/107")); delay(1000);
if(search_gyro(0x6B, 0x0F) == 0xD7){
Serial.println(F("L3GD20H found on address
0x6B")); type = 3;
gyro_address = 0x6B;
}
}

if(type == 0){
Serial.println(F("No gyro device found!!! (ERROR 3)"));
error = 1;
}

else{
delay(3000)
;
Serial.println(F(""));

Serial.println(F("==================================================="));
Serial.println(F("Gyro register settings"));

Serial.println(F("==================================================="));
start_gyro(); //Setup the gyro for further use
}
30
 }

//If the gyro is found we can setup the correct gyro axes.
if(error == 0){
delay(3000);
Serial.println(F(""
));

Serial.println(F("==================================================="));
Serial.println(F("Gyro calibration"));

Serial.println(F("==================================================="));
Serial.println(F("Don't move the quadcopter!! Calibration starts in 3 seconds"));
delay(3000);
Serial.println(F("Calibrating the gyro, this will take +/- 8 seconds"));
Serial.print(F("Please wait"));
//Let's take multiple gyro data samples so we can determine the average gyro offset
(calibration).
for (cal_int = 0; cal_int < 2000 ; cal_int ++){ //Take 2000 readings for calibration.
if(cal_int % 100 == 0)Serial.print(F(".")); //Print dot to indicate calibration.
gyro_signalen(); //Read the gyro output.
gyro_roll_cal += gyro_roll; //Ad roll value to gyro_roll_cal.
gyro_pitch_cal += gyro_pitch; //Ad pitch value to gyro_pitch_cal.
gyro_yaw_cal += gyro_yaw; //Ad yaw value to gyro_yaw_cal.
delay(4); //Wait 3 milliseconds before the next loop.
}
//Now that we have 2000 measures, we need to devide by 2000 to get the average gyro
offset.
gyro_roll_cal /= 2000; //Divide the roll total by 2000.
gyro_pitch_cal /= 2000; //Divide the pitch total by 2000.
gyro_yaw_cal /= 2000; //Divide the yaw total by 2000.

//Show the calibration results

Serial.println(F(""));
Serial.print(F("Axis 1 offset="));
Serial.println(gyro_roll_cal);
Serial.print(F("Axis 2 offset="));
Serial.println(gyro_pitch_cal);
Serial.print(F("Axis 3 offset="));
Serial.println(gyro_yaw_cal);
Serial.println(F(""));

Serial.println(F("==================================================="));
Serial.println(F("Gyroaxesconfiguration"));

Serial.println(F("==================================================="));

//Detect the left wing up movement

Serial.println(F("Lift the left side of the quadcopter to a 45 degree angle within 10
seconds"));
31
 //Check axis movement
check_gyro_axes(1);
if(error == 0){
Serial.println(F("OK!"
));
Serial.print(F("Angle detection = "));
Serial.println(roll_axis & 0b00000011);
if(roll_axis & 0b10000000)Serial.println(F("Axis inverted = yes"));
else Serial.println(F("Axis inverted = no"));
Serial.println(F("Put the quadcopter back in its original position"));
Serial.println(F("Move stick 'nose up' and back to center to continue"));
check_to_continue();
//Detect the nose up movement
Serial.println(F(""));
Serial.println(F(""));
Serial.println(F("Lift the nose of the quadcopter to a 45 degree angle within 10
seconds"));
//Check axis
movement
check_gyro_axes(2);
}
if(error==0){
Serial.println(F("OK!"));
Serial.print(F("Angle detection =
"));
Serial.println(pitch_axis & 0b00000011);
if(pitch_axis & 0b10000000)Serial.println(F("Axis inverted =
yes")); else Serial.println(F("Axis inverted = no"));
Serial.println(F("Put the quadcopter back in its original position"));
Serial.println(F("Move stick 'nose up' and back to center to continue"));
check_to_continue();

//Detect the nose right movement

Serial.println(F(""));
Serial.println(F(""));
Serial.println(F("Rotate the nose of the quadcopter 45 degree to the right within 10
seconds"));
//Check axis movement
check_gyro_axes(3);
}
if(error==0){
Serial.println(F("OK!"));
Serial.print(F("Angle detection =
"));
Serial.println(yaw_axis & 0b00000011);
if(yaw_axis & 0b10000000)Serial.println(F("Axis inverted =
yes")); else Serial.println(F("Axis inverted = no"));
Serial.println(F("Put the quadcopter back in its original position"));
Serial.println(F("Move stick 'nose up' and back to center to continue"));
check_to_continue();
}
32
 }
if(error == 0){
Serial.println(F(""
));

Serial.println(F("==================================================="));
Serial.println(F("LED test"));

Serial.println(F("==================================================="));
digitalWrite(12, HIGH);
Serial.println(F("The LED should now be lit"));
Serial.println(F("Move stick 'nose up' and back to center to continue"));
check_to_continue();
digitalWrite(12, LOW);
}
Serial.println(F(""));

if(error == 0){

Serial.println(F("==================================================="));
Serial.println(F("Final setup check"));

Serial.println(F("==================================================="));
delay(1000);
if(receiver_check_byte == 0b00001111){
Serial.println(F("Receiver channels
ok"));
}
else{
Serial.println(F("Receiver channel verification failed!!! (ERROR
6)")); error = 1;
}
delay(1000);
if(gyro_check_byte == 0b00000111){
Serial.println(F("Gyro axes ok"));
}
else{
Serial.println(F("Gyro exes verification failed!!! (ERROR
7)")); error = 1;
}
}

if(error == 0){
//If all is good, store the information in the EEPROM
Serial.println(F(""));

Serial.println(F("==================================================="));
Serial.println(F("Storing EEPROM information"));

Serial.println(F("==================================================="));
Serial.println(F("Writing
33
 EEPROM")); delay(1000);
Serial.println(F("Done!"));
EEPROM.write(0,center_channel_1&0b11111111;
EEPROM.write(1, center_channel_1 >> 8);
EEPROM.write(2,center_channel_2&0b11111111;
EEPROM.write(3, center_channel_2 >> 8);
EEPROM.write(4,center_channel_3&0b11111111;
EEPROM.write(5, center_channel_3 >> 8);
EEPROM.write(6,center_channel_4&0b11111111;
EEPROM.write(7, center_channel_4 >> 8);
EEPROM.write(8,high_channel_1& 0b11111111);
EEPROM.write(9, high_channel_1 >> 8);
EEPROM.write(10,high_channel_2&0b11111111;
EEPROM.write(11, high_channel_2 >> 8);
EEPROM.write(12, high_channel_3 & 0b11111111);
EEPROM.write(13, high_channel_3 >> 8);
EEPROM.write(14, high_channel_4 & 0b11111111);
EEPROM.write(15, high_channel_4 >> 8);
EEPROM.write(16, low_channel_1 & 0b11111111);
EEPROM.write(17, low_channel_1 >> 8);
EEPROM.write(18, low_channel_2 & 0b11111111);
EEPROM.write(19, low_channel_2 >> 8);
EEPROM.write(20, low_channel_3 & 0b11111111);
EEPROM.write(21, low_channel_3 >> 8);
EEPROM.write(22, low_channel_4 & 0b11111111);
EEPROM.write(23, low_channel_4 >> 8);
EEPROM.write(24,channel_1_assign);
EEPROM.write(25,channel_2_assign);
EEPROM.write(26,channel_3_assign);
EEPROM.write(27,channel_4_assign);
EEPROM.write(28, roll_axis);
EEPROM.write(29, pitch_axis);
EEPROM.write(30, yaw_axis);
EEPROM.write(31, type);
EEPROM.write(32,gyro_addres;
//Write the EEPROM signature
EEPROM.write(33, 'J');
EEPROM.write(34, 'M');
EEPROM.write(35, 'B');

//To make sure evrything is ok, verify the EEPROM data.

Serial.println(F("Verify EEPROM data"));
delay(1000);
if(center_channel_1!=((EEPROM.read(1)<< 8) | EEPROM.read(0)))error=
1;if(center_channel_2!=((EEPROM.read(3)<<8) | EEPROM.read(2)))error
=1;if(center_channel_3!=((EEPROM.read(5)<<8)|EEPROM.read(4)))error
=1;if(center_channel_4!=((EEPROM.read(7)<<8)|EEPROM.read(6)))error
= 1;

if(high_channel_1 != ((EEPROM.read(9) << 8) | EEPROM.read(8)))error = 1;

34
if(high_channel_2!= ((EEPROM.read(11) << 8) | EEPROM.read(10)))error = 1;
if(high_channel_3 != ((EEPROM.read(13) << 8) | EEPROM.read(12)))error = 1;
if(high_channel_4 != ((EEPROM.read(15) << 8) | EEPROM.read(14)))error = 1;

if(low_channel_1 != ((EEPROM.read(17) << 8) | EEPROM.read(16)))error = 1;

if(low_channel_2 != ((EEPROM.read(19) << 8) | EEPROM.read(18)))error = 1;
if(low_channel_3 != ((EEPROM.read(21) << 8) | EEPROM.read(20)))error = 1;
if(low_channel_4 != ((EEPROM.read(23) << 8) | EEPROM.read(22)))error = 1;

if(channel_1_assign != EEPROM.read(24))error = 1;
if(channel_2_assign != EEPROM.read(25))error = 1;
if(channel_3_assign != EEPROM.read(26))error = 1;
if(channel_4_assign != EEPROM.read(27))error = 1;

if(roll_axis != EEPROM.read(28))error = 1;
if(pitch_axis != EEPROM.read(29))error = 1;
if(yaw_axis != EEPROM.read(30))error = 1;
if(type != EEPROM.read(31))error = 1;
if(gyro_address != EEPROM.read(32))error
= 1;

if('J'!=EEPROM.read(33))error =1;
if('M'!=EEPROM.read(34))error=1
;if('B'!=EEPROM.read(35))error=1
;

if(error == 1)Serial.println(F("EEPROM verification failed!!! (ERROR

5)")); else Serial.println(F("Verification done"));
}

if(error == 0){
Serial.println(F("Setup is finished."));
Serial.println(F("You can now calibrate the esc's and upload the YMFC-AL code."));
}
else{
Serial.println(F("The setup is aborted due to an error."));
Serial.println(F(""));
Serial.println(F(""));
}
while(1);
}

//Search for the gyro and check the Who_am_I register

byte search_gyro(int gyro_address, int who_am_i){
Wire.beginTransmission(gyro_address);
Wire.write(who_am_i);
Wire.endTransmission();
Wire.requestFrom(gyro_address,
1); timer = millis() + 100;
while(Wire.available() < 1 && timer > millis());
35
 lowByte = Wire.read();
address =
gyro_address; return
lowByte;
}

void start_gyro(){
//Setup the L3G4200D or L3GD20H
if(type == 2 || type == 3){
Wire.beginTransmission(address); //Start communication with the gyro
with the address found during search
Wire.write(0x20); //We want to write to register 1 (20 hex)
Wire.write(0x0F); //Set the register bits as 00001111 (Turn on
the gyro and enable all axis)
Wire.endTransmission(); //End the transmission with the gyro

Wire.beginTransmission(address); //Start communication with the gyro

(adress 1101001)
Wire.write(0x20); //Start reading @ register 28h and auto
increment with every read
Wire.endTransmission(); //End the transmission
Wire.requestFrom(address, 1); //Request 6 bytes from the gyro
while(Wire.available() < 1); //Wait until the 1 byte is received
Serial.print(F("Register 0x20 is set to:"));
Serial.println(Wire.read(),BIN);

Wire.beginTransmission(address); //Start communication with the gyro

with the address found during search
Wire.write(0x23); //We want to write to register 4 (23 hex)
Wire.write(0x90); //Set the register bits as 10010000 (Block
Data Update active & 500dps full scale)
Wire.endTransmission(); //End the transmission with the gyro

Wire.beginTransmission(address); //Start communication with the gyro

(adress 1101001)
Wire.write(0x23); //Start reading @ register 28h and auto
increment with every read
Wire.endTransmission(); //End the transmission
Wire.requestFrom(address, 1); //Request 6 bytes from the gyro
while(Wire.available() < 1); //Wait until the 1 byte is received
Serial.print(F("Register 0x23 is set to:"));
Serial.println(Wire.read(),BIN);

}
//Setup the MPU-6050
if(type == 1){

Wire.beginTransmission(address); //Start communication with the gyro

Wire.write(0x6B); //PWR_MGMT_1 register
Wire.write(0x00); //Set to zero to turn on the gyro
36
 Wire.endTransmission(); //End the transmission

Wire.beginTransmission(address); //Start communication with the gyro

Wire.write(0x6B); //Start reading @ register 28h and auto
increment with every read
Wire.endTransmission(); //End the transmission
Wire.requestFrom(address, 1); //Request 1 bytes from the gyro
while(Wire.available() < 1); //Wait until the 1 byte is received
Serial.print(F("Register 0x6B is set to:"));
Serial.println(Wire.read(),BIN);

Wire.beginTransmission(address); //Start communication with the gyro

Wire.write(0x1B); //GYRO_CONFIG register
Wire.write(0x08); //Set the register bits as 00001000 (500dps
full scale)
Wire.endTransmission(); //End the transmission

Wire.beginTransmission(address); //Start communication with the gyro

(adress 1101001)
Wire.write(0x1B); //Start reading @ register 28h and auto
increment with every read
Wire.endTransmission(); //End the transmission
Wire.requestFrom(address, 1); //Request 1 bytes from the gyro
while(Wire.available() < 1); //Wait until the 1 byte is received
Serial.print(F("Register 0x1B is set to:"));
Serial.println(Wire.read(),BIN);

}
}

voidgyro_signalen(){
if(type== 2 || type == 3){
Wire.beginTransmission(address); //Start communication with the gyro
Wire.write(168); //Start reading @ register 28h and auto
increment with every read
Wire.endTransmission(); //End the transmission
Wire.requestFrom(address, 6); //Request 6 bytes from the gyro
while(Wire.available() < 6); //Wait until the 6 bytes are received
lowByte = Wire.read(); //First received byte is the low part of the
angular data
highByte = Wire.read(); //Second received byte is the high part of
the angular data
gyro_roll = ((highByte<<8)|lowByte); //Multiply highByte by 256 (shift left
by 8) and ad lowByte
if(cal_int == 2000)gyro_roll -= gyro_roll_cal; //Only compensate after the
calibration
lowByte = Wire.read(); //First received byte is the low part of the
angular data
highByte = Wire.read(); //Second received byte is the high part of
the angular data
37
 gyro_pitch = ((highByte<<8)|lowByte); //Multiply highByte by 256 (shift
left by 8) and ad lowByte
if(cal_int == 2000)gyro_pitch -= gyro_pitch_cal; //Only compensate after the
calibration
lowByte = Wire.read(); //First received byte is the low part of the
angular data
highByte = Wire.read(); //Second received byte is the high part of
the angular data
gyro_yaw = ((highByte<<8)|lowByte); //Multiply highByte by 256 (shift
left by 8) and ad lowByte
if(cal_int == 2000)gyro_yaw -= gyro_yaw_cal; //Only compensate after the
calibration
}
if(type == 1){
Wire.beginTransmission(address); //Start communication with the gyro

Wire.write(0x43); //Start reading @ register 43h and auto

increment with every read
Wire.endTransmission(); //End the transmission
Wire.requestFrom(address,6); //Request 6 bytes from the gyro
while(Wire.available() < 6); //Wait until the 6 bytes are received
gyro_roll=Wire.read()<<8|Wire.read(); //Read high and low part of the
angular data
if(cal_int == 2000)gyro_roll -= gyro_roll_cal; //Only compensate after the
calibration
gyro_pitch=Wire.read()<<8|Wire.read(); //Read high and low part of the
angular data
if(cal_int == 2000)gyro_pitch -= gyro_pitch_cal; //Only compensate after the
calibration
gyro_yaw=Wire.read()<<8|Wire.read(); //Read high and low part of the
angular data
if(cal_int == 2000)gyro_yaw -= gyro_yaw_cal; //Only compensate after the
calibration
}
}

//Check if a receiver input value is changing within 30 seconds

void check_receiver_inputs(byte movement){
byte trigger =
0; int
pulse_length;
timer = millis() + 30000;
while(timer > millis() && trigger ==
0){ delay(250);
if(receiver_input_channel_1 > 1750 || receiver_input_channel_1 <
1250){ trigger = 1;
receiver_check_byte |= 0b00000001;
pulse_length =
receiver_input_channel_1;
38
 }
if(receiver_input_channel_2>1750||receiver_input_channel_2<1250){
trigger = 2;
receiver_check_byte|=0b00000010;
pulse_length=receiver_input_channel2;
}
if(receiver_input_channel_3>1750||receiver_input_channel_3 < 1250){
trigger = 3;
receiver_check_byte|=0b00000100;
pulse_length=receiver_input_channel3;
}
if(receiver_input_channel_4>1750||receiver_input_channel_4 < 1250){
trigger = 4;
receiver_check_byte|=0b00001000;
pulse_length=receiver_input_channel4;
}
}
if(trigger == 0){
error = 1;
Serial.println(F("No stick movement detected in the last 30 seconds!!! (ERROR 2)"));
}
//Assign the stick to the function.
else{
if(movement == 1){
channel_3_assign =
trigger;
if(pulse_length < 1250)channel_3_assign += 0b10000000;
}
if(movement == 2){
channel_1_assign =
trigger;
if(pulse_length < 1250)channel_1_assign += 0b10000000;
}
if(movement == 3){
channel_2_assign =
trigger;
if(pulse_length < 1250)channel_2_assign += 0b10000000;
}
if(movement == 4){
channel_4_assign =
trigger;
if(pulse_length < 1250)channel_4_assign += 0b10000000;
}
}
}

void check_to_continue(){
byte continue_byte = 0;
while(continue_byte ==
0){
if(channel_2_assign == 0b00000001 && receiver_input_channel_1 >
39
center_channel_1 + 150)continue_byte = 1;
if(channel_2_assign == 0b10000001 && receiver_input_channel_1 <
center_channel_1 - 150)continue_byte = 1;
if(channel_2_assign == 0b00000010 && receiver_input_channel_2 > center_channel_2 +
150)continue_byte = 1;
if(channel_2_assign == 0b10000010 && receiver_input_channel_2 <
center_channel_2 - 150)continue_byte = 1;
if(channel_2_assign == 0b00000011 && receiver_input_channel_3 > center_channel_3 +
150)continue_byte = 1;
if(channel_2_assign == 0b10000011 && receiver_input_channel_3 <
center_channel_3 - 150)continue_byte = 1;
if(channel_2_assign == 0b00000100 && receiver_input_channel_4 > center_channel_4 +
150)continue_byte = 1;
if(channel_2_assign == 0b10000100 && receiver_input_channel_4 <
center_channel_4 - 150)continue_byte = 1;
delay(100);
}
wait_sticks_zero();
}

//Check if the transmitter sticks are in the neutral

position void wait_sticks_zero(){
byte zero = 0;

while(zero < 15){

if(receiver_input_channel_1 < center_channel_1 + 20 &&
receiver_input_channel_1 > center_channel_1 - 20)zero |= 0b00000001;
if(receiver_input_channel_2 < center_channel_2 + 20 &&
receiver_input_channel_2 > center_channel_2 - 20)zero |= 0b00000010;
if(receiver_input_channel_3 < center_channel_3 + 20 &&
receiver_input_channel_3 > center_channel_3 - 20)zero |= 0b00000100;
if(receiver_input_channel_4 < center_channel_4 + 20 &&
receiver_input_channel_4 > center_channel_4 - 20)zero |= 0b00001000;
delay(100);
}
}

//Checck if the receiver values are valid within 10 seconds

void wait_for_receiver(){
byte zero = 0;
timer = millis() + 10000;
while(timer > millis() && zero < 15){
if(receiver_input_channel_1 < 2100 && receiver_input_channel_1 >
900)zero |= 0b00000001;
if(receiver_input_channel_2 < 2100 && receiver_input_channel_2 >
900)zero |= 0b00000010;
if(receiver_input_channel_3 < 2100 && receiver_input_channel_3 >
900)zero |= 0b00000100;
if(receiver_input_channel_4 < 2100 && receiver_input_channel_4 >
900)zero |= 0b00001000;
delay(500);
40
 Serial.print(F("."
));
}
if(zero == 0){
error = 1;
Serial.println(F("."
));
Serial.println(F("No valid receiver signals found!!! (ERROR 1)"));
}
else Serial.println(F(" OK"));
}

//Register the min and max receiver values and exit when the sticks are back in the neutral
position
void
register_min_max(){
byte zero = 0;
low_channel_1 =
receiver_input_channel_1;
low_channel_2 =
receiver_input_channel_2;
low_channel_3 =
receiver_input_channel_3;
low_channel_4 =
receiver_input_channel_4;
while(receiver_input_channel_1 < center_channel_1 + 20 && receiver_input_channel_1 >
center_channel_1 - 20)delay(250);
Serial.println(F("Measuring
endpoints....")); while(zero < 15){

if(receiver_input_channel_1 < center_channel_1 + 20 &&

receiver_input_channel_1 > center_channel_1 - 20)zero |= 0b00000001;
if(receiver_input_channel_2 < center_channel_2 + 20 &&
receiver_input_channel_2 > center_channel_2 - 20)zero |= 0b00000010;
if(receiver_input_channel_3 < center_channel_3 + 20 &&
receiver_input_channel_3 > center_channel_3 - 20)zero |= 0b00000100;
if(receiver_input_channel_4 < center_channel_4 + 20 &&
receiver_input_channel_4 > center_channel_4 - 20)zero |= 0b00001000;
if(receiver_input_channel_1 < low_channel_1)low_channel_1 =
receiver_input_channel_1;
if(receiver_input_channel_2 < low_channel_2)low_channel_2 =
receiver_input_channel_2;
if(receiver_input_channel_3 < low_channel_3)low_channel_3 =
receiver_input_channel_3;
if(receiver_input_channel_4 < low_channel_4)low_channel_4 =
receiver_input_channel_4;
if(receiver_input_channel_1 > high_channel_1)high_channel_1 =
receiver_input_channel_1;
if(receiver_input_channel_2 > high_channel_2)high_channel_2 =
receiver_input_channel_2;
if(receiver_input_channel_3 > high_channel_3)high_channel_3 =
41
receiver_input_channel_3;
if(receiver_input_channel_4 > high_channel_4)high_channel_4 =
receiver_input_channel_4;
delay(100);
}
}

//Check if the angular position of a gyro axis is changing within 10 seconds

void check_gyro_axes(byte movement){
byte trigger_axis = 0;
float gyro_angle_roll, gyro_angle_pitch, gyro_angle_yaw;
//Reset all axes
gyro_angle_roll = 0;
gyro_angle_pitch = 0;
gyro_angle_yaw =
0; gyro_signalen();
timer = millis() + 10000;
while(timer > millis() && gyro_angle_roll > -30 && gyro_angle_roll < 30
&& gyro_angle_pitch > -30 && gyro_angle_pitch < 30 && gyro_angle_yaw >
-30 && gyro_angle_yaw < 30){
gyro_signalen();
if(type == 2 || type == 3){
gyro_angle_roll += gyro_roll * 0.00007; //0.00007 = 17.5 (md/s) /
250(Hz) gyro_angle_pitch += gyro_pitch * 0.00007;
gyro_angle_yaw += gyro_yaw * 0.00007;
}
if(type == 1){
gyro_angle_roll += gyro_roll * 0.0000611; // 0.0000611 = 1 / 65.5 (LSB degr/s)
/ 250(Hz)

gyro_angle_pitch += gyro_pitch *
0.0000611; gyro_angle_yaw += gyro_yaw *
0.0000611;
}

delayMicroseconds(3700); //Loop is running @ 250Hz. +/-300us is used

for communication with the gyro
}
//Assign the moved axis to the orresponding function (pitch, roll, yaw)
if((gyro_angle_roll < -30 || gyro_angle_roll > 30) && gyro_angle_pitch > -30 &&
gyro_angle_pitch < 30 && gyro_angle_yaw > -30 && gyro_angle_yaw < 30){
gyro_check_byte |= 0b00000001;
if(gyro_angle_roll < 0)trigger_axis =
0b10000001; else trigger_axis = 0b00000001;
}
if((gyro_angle_pitch < -30 || gyro_angle_pitch > 30) && gyro_angle_roll > -30
&& gyro_angle_roll < 30 && gyro_angle_yaw > -30 && gyro_angle_yaw < 30){
gyro_check_byte |= 0b00000010;
if(gyro_angle_pitch < 0)trigger_axis =
0b10000010; else trigger_axis = 0b00000010;
}
42
 if((gyro_angle_yaw < -30 || gyro_angle_yaw > 30) && gyro_angle_roll > -30
&& gyro_angle_roll < 30 && gyro_angle_pitch > -30 && gyro_angle_pitch <
30){
gyro_check_byte |= 0b00000100;
if(gyro_angle_yaw < 0)trigger_axis =
0b10000011; else trigger_axis = 0b00000011;
}

if(trigger_axis == 0){
error = 1;
Serial.println(F("No angular motion is detected in the last 10 seconds!!! (ERROR 4)"));
}
else
if(movement == 1)roll_axis = trigger_axis;
if(movement == 2)pitch_axis = trigger_axis;
if(movement == 3)yaw_axis = trigger_axis;

//This routine is called every time input 8, 9, 10 or 11 changed state

ISR(PCINT0_vect){
current_time = micros();
//Channel 1=========================================
if(PINB & B00000001){ //Is input 8 high?
if(last_channel_1 == 0){ //Input 8 changed from 0 to 1
last_channel_1 = 1; //Remember current input state
timer_1 = current_time; //Set timer_1 to current_time
}
}
else if(last_channel_1 == 1){ //Input 8 is not high and changed from 1 to
0
last_channel_1 = 0; //Remember current input state
receiver_input_channel_1 = current_time - timer_1; //Channel 1 is current_time -
timer_1
}
//Channel 2=========================================
if(PINB & B00000010 ){ //Is input 9 high?
if(last_channel_2 == 0){ //Input 9 changed from 0 to 1
last_channel_2 = 1; //Remember current input state
timer_2 = current_time; //Set timer_2 to current_time
}
}
else if(last_channel_2 == 1){ //Input 9 is not high and changed from 1 to
0
last_channel_2 = 0; //Remember current input state
receiver_input_channel_2 = current_time - timer_2; //Channel 2 is current_time -
timer_2
}
//Channel 3=========================================
if(PINB & B00000100 ){ //Is input 10 high?
if(last_channel_3 == 0){ //Input 10 changed from 0 to 1
43
 last_channel_3 = 1; //Remember current input state
timer_3 = current_time; //Set timer_3 to current_time
}
}
else if(last_channel_3 == 1){ //Input 10 is not high and changed from 1
to 0
last_channel_3 = 0; //Remember current input state
receiver_input_channel_3 = current_time - timer_3; //Channel 3 is current_time -
timer_3

}
//Channel 4=========================================
if(PINB & B00001000 ){ //Is input 11 high?
if(last_channel_4 == 0){ //Input 11 changed from 0 to 1
last_channel_4 = 1; //Remember current input state
timer_4 = current_time; //Set timer_4 to current_time
}
}
else if(last_channel_4 == 1){ //Input 11 is not high and changed from 1
to 0
last_channel_4 = 0; //Remember current input state
receiver_input_channel_4 = current_time - timer_4; //Channel 4 is current_time -
timer_4
}
}

//Intro subroutine
void intro(){
Serial.println(F("==================================================="));
delay(1500);

delay(500);
Serial.println(F(" "));
delay(500);
Serial.println(F("
Flight"))
; delay(500);
Serial.println(F("
Controller")
); delay(1000);
Serial.println(F(""));
Serial.println(F("Setup Program"));
Serial.println(F(""));
Serial.println(F("==================================================="));
delay(1500);
}

44
45
 CHAPTER 5
RESULTS & FUTURE SCOPE

5.1 RESULTS OF DISCUSSION

Firstly, the values of different sensors are displayed on the serial monitor while interfacing
with Arduino. Then, a Wi-Fi network is created and the server-client concept is implemented
using two ESP8266 modules. Next, the various data of the sensors are displayed on the client
side’s serial monitor. Lastly, the calibration and the setup of the quadcopter is achieved
through transmitter and the controlling of the motors with the different speeds of rotation is
done.

Fig 5.1: Server Client Concept

5.2 FUTURE SCOPE OF STUDY

In this project, we have developed a quadcopter using Arduino microcontroller, which will be
used in remote package delivering as well as in search & rescue operations. The quadcopter
at present is being manually controlled using a remote-controlled transmitter. But in future,
an autonomous control can be incorporated using a pre-designed algorithm. Additionally, a
camera could be fixed on the quadcopter for a live transmission of the location to where the
quadcopter is flying. This feature can be used to survey a remote location from a safe location
without actually going there. Also, the coordinates of the remote location can be obtained by
attaching a GPS module in the quadcopter.

46
 REFERENCES
[1] Quad Copter Flight Dynamics [INTERNATIONAL JOURNAL OF SCIENTIFIC &
TECHNOLOGY RESEARCH VOLUME 3, ISSUE 8, AUGUST 2014 by Mohd Khan]

[2] Design And Assembling Of A Low UAV [Umberto Papa1, Giuseppe Del Core2 Department
of Science and Technology, University of Naples "Parthenope"]

[3] Low Cost Microcontroller Based Hover Control Design Of A Quad Copter [Bernard Tat Meng
Leong, Sew Ming Low, Melanie Po-Leen Ooi, School of Engineering, Monash University, Sunway
Campus, Bandar Sunway, 46150 Selangor Darul Ehsan, Malaysia]

[4] Stability Control For Quadcopter With An Autonomous Flight System [ABDUL HALIM BIN
MOHD MUSTAFFA, Faculty of Electronic and Computer Engineering, University Teknikal Melaka
(UTeM)]

[5] Stabilization And Control Of Unmanned Quadcopter [Tomáš Jiinec Master of Science
Space Engineering - Space Master, Luleå University of Technology, Department of Computer
Science, Electrical and Space Engineering]

[6] Simple GUI Wireless Controller Of Quadcopter [Int'l J. of Communications, Network and System
Sciences, Vol.6 No.1(2013), Article ID:27464,8 pagesDOI:10.4236/ijcns.2013.61006 by Dirman
Hanafi1 , Mongkhun Qetkeaw1 , Rozaimi Ghazali1 , Mohd Nor Mohd Than1 , Wahyu Mulyo Utomo2 ,
Rosli Omar1 , University Tun Hussein Onn Malaysia]

[7] An Android-Based Arduino-Governed Unmanned Quadcopter Platform [Carles Carruesco Picas

, University of Catalunya, Barcelona]

[8] Algorithm Development And Testing Of Low Cost Waypoint Navigation System [IRACST –
Engineering Science and Technology: An International Journal (ESTIJ), ISSN: 2250-3498, Vol.3, No.2,
April 2013, by M.Rengarajan1, Dr.G.Anitha2, Division of Avionics Department of Aerospace
Engineering, M.I.T campus, Anna University Chennai]
[9] Design And Implementation Of Multitasking Flying Robot [Sahyadri R. Mane1, Prakash S.
Andhare2, Swapnali B. Gaikwad3 1,2,3Fabtech Technical Campus College of Engg. Sangola, Solapur,]

[10] Developing A Multicopter Uav Camera

[11] Wireless Control Quadcopter With Stereo Camera [MONGKHUN QETKEAW A/L
VECHIAN, Faculty of Electrical and Electronics Engineering, University Tun Hussein Onn
Malaysia]

[12] Fertilizer Spraying Quadcopter Using Arduino UNO [ IJSTE - International Journal of
Science Technology & Engineering | Volume 3 | Issue 09 | March 2017]

[13] Design And Implementation Of A Real Time Wireless Quadcopter For Rescue
Operations [ Gordon Ononiwu1, Arinze Okoye2, James Onojo3, Nnaemeka Onuekwusi4 1, 2, 3, 4
(Department of Electrical and Electronic Engineering, Federal University of Technology Owerri,
Nigeria), American Journal of Engineering Research (AJER)]
[14] Quad Copter For Using Agricultural Surveillance [Advance in Electronic and Electric
Engineering, ISSN 2231-1297, Volume 3, Number 4 (2013), pp. 427-432, Parth N. Patel1, Malav A.
Patel2, Rahul
M. Faldu3and Yash R. Dave4, B.E. Mechatronics, Vallabh Vidyanagar, India]

[15] Research On The Use Of Drones In Precision Agriculture [George IPATE, Gheorghe
VOICU, Ion DINU]
47
 [16] Use Of UAVS In USA [https://www.researchgate.net/publication/261493641, by
Eduardo I. Ortiz- Rivera, Ph.D Minds CREATE Research Team Leader, University of Puerto Rico-
Mayaguez, Dept. of Electrical and Computer Engineering & Angelina Estela, Carlos Romero,
Jesus A. Valentin, Department of Mechanical Engineering, Mayaguez, Puerto Rico]
[17] Quadcopter- Obstacle detection & Collision Avoidance [International Journal of
Engineering Trends and Technology (IJETT) – Volume 17 Number 2 – Nov 2014, Prathamesh
Salaskar1, Saee Paranjpe2, Jagdish Reddy3, Arish Shah4, Atharva College of Engineering,
University of Mumbai, India]

[18] Collision Avoidance Protocol For Package Delivering Quadcopter [Erick Camacho, Marco
Robaina, Alessandro Tasca, Pedro Cuberos, Ibrahim Tansel, Sabri Tosunoglu Florida International
University, Department of Mechanical and Materials Engineering 10555 West Flagler Street, Miami,
Florida]

[19] Towards The Development Of A Low Cost Airborne Sensing System To Monitor Dust
Particles After Blasting At Open Space [Miguel Alvarado, Felipe Gonzalez, Andrew Fletcher and
Ashray Doshi]

[20] Building A Hands-Free Quadcopter [Frau Amar, Pedro, Department of

Information and Communication Technologies, POLYTECHNIC SCHOOL UPF]

[21] Gesture Controlled Quadcopter [ ESSENCE - International Journal for

Environmental Rehabilitation and Conservation Volume VI: No. 2 2015 [126 – 129], by
Gaur, Vivek; Mishra Abhishek; Aquil, Manal; Thapa, Himanshi and Verma, Rahul
Kumar]

[22] http://espressif.com/sites/default/files/documentation/0a-esp8266ex_datasheet_en.pdf [25/10/2019]

[23] https://www.invensense.com/wp-content/uploads/2015/02/MPU-6000-Datasheet1.pdf [05/11/2019]
[24] https://en.wikipedia.org/wiki/Quadcopter [15/08/2019]
[25] https://www.dronezon.com/learn-about-drones-quadcopters/how-a-
quadcopter-works-with-propellers-and-motors-direction-design-explained

48