D SMD

Graduation Project

Our Idea

The goal of this project is to construct a physical FANET, outside the simulator, this can be done by constructing a number of drones built on the ESP-Drone repository, along with our own PCB and a 3D printed drone body. The FANET nodes will communicate with each other using LoRaWAN through our own modified AODV routing protocol. The FANET is planned to operate over the area of Birzeit University.

Since we will be using light-weight drones for nodes, the weight of anything carried by drones is critical, for this reason we decided on using the LoRa32 microcontroller, that integrates the ESP32 chip along with the LoRa module in a compact package, which weighs about 18grams, our testing shows a current draw of 45-50 mA during normal operations, goes up by 10 mA during transmission/reception

Step 1: Build ESP23 Drone

Since the scope of the project is rapidly expanding, we don’t have enough time to design and build a drone from scratch, instead we will be using Espressif Systems’ drone design.

For more information on getting started, visit the Espressif ESP-Drone Documentation.

Hardware Part

1. Components

   We faced some difficulties in providing the parts because we are restricted by the Israeli occupation and the high cost of the parts, but the parts were eventually provided with great difficulty.

   • Basic Component List

   Component	Number	Notes
   Main board	1	ESP32 LORA V3 + MPU6050
   Frame	1	We Build it using 3D printer
   716 motor	4	Optional: 720 motor
   46mm propeller A	2
   46mm propeller B	2
   1000mAh 1s LiPo battery	1

   1. Frame

   Steps to make the Frame:

   

   Final Output:

   
   2. Main Controller
   

   Chip	Module	Battery	Dimensions
   ESP32-S3FN8	ESP32 LORA V3	3.7V lithium battery	50.2 * 25.5* 10.2 mm

   3. Sensor
   

   Sensor	Interface	Notes
   MPU6050	I2C0	Main board sensor

   3. Motor
   

   Motor	Type	Notes
   716 motor	Coreless motor	Use 720 if you have issue in altitude

   3. Battery
   

   Battery	Voltage	Dimensions	Dimensions
   1000mAh 1s LiPo battery	3.7V (1S)	48 x 30 x 9	28.5

   • Definition of Main Board IO

   Pins	Function	Notes
   GPIO23	I2C0_SDA	Only for MPU6050
   GPIO22	I2C0_SCL	Only for MPU6050
   GPIO2	interrupt	MPU6050 interrupt
   GPIO12	MOT_1
   GPIO35	MOT_2
   GPIO32	MOT_3
   GPIO33	MOT_4
   GND		With Ground
   3V3		With VCC of MPU6050

2. PCB

   As is previously, our drone design is light-weight, so we will need to conserve as much as possible on the drone weight, and therefore we found it best to construct our own PCB.

   Scheme Below show our PCB design:

   

   Steps to make our PCB:

   

   The Link below show some videos While working on the production of the PCB (https://google.com)

   You Can Find All File You Needed in (PCB) Folder

Software Part

Set up ESP-IDF Environment

Please refer to ESP-IDF Programming Guide and set up ESP-IDF environmnet step by step.

• ESP-IDF branch release /v4.4 is suggested.

• Please follow and complete all setup steps.

• Build a example of ESP-IDF to make sure the setup is successful.

Get Project Source Code

Beta code, currently in the GitHub repository, is available by using git:

git clone https://github.com/espressif/esp-drone.git

The project software mainly consists of a flight control kernel, hardware drivers, and dependency libraries:

• The flight control kernel is from Crazyflie, mainly including hardware abstraction layer and flight control program.

• Hardware drivers are structured in files according to hardware interfaces, including I2C devcies and SPI devices.

• Dependency libraries include the default components provided by ESP-IDF, as well as DSP from third parties.

The code file structure is as follows:

Download and Install ESP-Drone APP

ESP-Drone APP is available for Android and iOS.

For Android, please scan the QR below to download ESP-Drone APP.

For iOS, please search and download the ESP-Drone APP in App Store.

iOS APP source code: ESP-Drone-iOS

Android APP source code: ESP-Drone-Android

Flight Control

• Click “Connect” button/icon at your APP. When the connection is established successfully between your drone and APP, the LED on the drone blinks GREEN.

• Slide “Thrust” slightly to take off the drone.

• Control the flight by moving your fingers on the APP.

Step 2: Routing Protocol

we will be using a LoRa module for transmission/Re- ception between nodes in our physical test bench, the LoRa module is chosen for its extended range, up to 14Km at SF12, and extremely low current draw, our own testing showed an 10 mA increase in current draw at transmission/re- ception at SF7, matching the datasheet specification.

The drawback to all this, is the low bandwidth, 290 bps at SF12, choosing a lower spread factor, will provide a higher bandwidth at a lower range, SF7 is rated to give 5470 bps for 2km, a range of 2km is well above our needs for this project, the bit rate is also sufficient for the communication protocol used, table 2 shows LoRa transmission ranges and bandwidth at different Spread Factors.

Our routing protocol builds upon the AODV protocol, and improves on it in two substantial ways, multiple paths and speed dependent route lifetime. The AODV routing protocol establishes a singular path for packets to travel from the source node to the destination node, however this can be unreliable in unstable networks, therefore establishing multiple paths will incur small overhead for the reward of a more reliable communication link, this is proposed in the AOMDV routing protocol.

The AODV routing protocol doesn’t provide a method to calculate the lifetime of established routes between nodes, ns3 simulator keeps an arbitrary period of time of 10 seconds, we suggest making use of the instantaneous speed of each node in the calculation of the lifetime, where the lifetime of any path is decided by the speed of the nodes in the path at route instantiation, equation below is followed when calculating the lifetime of any route established between any two nodes, where Sx is the speed of node x at the time of RREP packet transmission/forwarding, and  is scalar hyperparameter used for scaling the lifetime of all routes.

Currently, we were able to construct the lifetime calculations on the ns3 simulator and it has yield promising results, as it outperformed the AODV protocol in terms on Packet Receive Rate, this is probably at the cost of increased routing calculations.

Multi-path implementation is currently stagnate as some unexpected difficulties were faced.

• Part 1: code inspection and review of ns3 aodv implementtion

• Part 2: code inspection of ns3 mobility models to obtain speed

• Part 3: implantation of speed reliant timeout

• Part 4: attempt at implementing multi-path protocol(fail)

• Part 5: implement RREQ and RERR counter

• Part 6: Simulation results at different max_distance parameter values