Team Drone On Guard:

Noah Schwartz

•

Ryan Unger

•

Charles Robson

Published May 6, 2019 © GPL3+

Drone on a Leash

A BeagleBone Blue powered drone that will follow you around on a leash.

AdvancedFull instructions provided20 hours10,002

Things used in this project

Hardware components

BeagleBoard.org BeagleBone Blue

The autopilot and companion computer for the drone.

HobbyKing™ SMACK 300 Premium FPV Ready Folding Drone Frame (KIT)

Lightweight and small frame to mount everything on.

Emax 4pc RS2205 2600KV Brushless Motor

High powered motors that will provide more than enough thrust to fly our drone and the leash.

Night Flying Propeller 5x3 Clear (CW/CCW) (4pcs)

Cheap and light weight propellers that are compatible with the motors and the frame. Definitely get more than one set in case you break one.

Turnigy MultiStar 30A BLHeli-S Rev16 V3 ESC 2~4S (Opto)

Electronic speed controllers that drive the motors. The pwm input comes from the beaglebone.

1500 mAh 4S 100C Lipo Battery

Plenty of other battery options. Just make sure the capacity is high enough, without being too heavy. The motors/ESCs are meant to go with a 4S battery. We recommend getting more than one so it can charge while the other is flying.

LiPo voltage alarm

Very loud, but very important. We accidentally killed the capacity of one of our batteries by having it discharge too much. This item solves that.

2.4Ghz A-FHSS Compatible 8CH Receiver (Hitec Minima compatible)

PPM compatible receiver, the beaglebone blue uses PPM for the RC controller.

Aurora 9 - 9 Channel 2.4GHz Aircraft Computer Radio

Discontinued, but any transmitter receiver combo that outputs PPM should work fine.

Analog joystick (Generic)

We used one from Adafruit. https://www.adafruit.com/product/512 While it is now out of stock, practically any 2 axis analog voltage divider joystick with a decent range of motion would work.

Dog Leash 26

The longest dog leash I could find online. Anything would work here, even strong rope.

Power Distribution Board

Battery output to the ESCs and Beaglebone Blue. As simple as some heavy gauge wire, or a power distribution board with all the wire soldered to it.

Renaissance Robotics JST Jumper Bundle for the BeagleBone Blue

We didn't have this, but it would have saved a lot of trouble. You need one 4 wire and one 6 wire. https://github.com/beagleboard/beaglebone-blue/wiki/Accessories

Turnigy MultiStar 32Bit ESC Program Card

Technically optional, but it will be much easier to program the ESCs with this, rather than using timed RC commands.

Story

Intro

Our team was actually assigned this project as a school project. Our task was to build a drone on a leash to mimic other projects, while being safe and open source.

The video we made for our class

If you've ever built a drone with a BeagleBone Blue as the companion computer/autopilot you know how it can be relatively simple overall. Sure there are quirks to run into, but overall, there was relatively little headache.

These instructions assume minimal experience with drones/BeagleBone Blue at all. Here's how you'll want to start.

Step 1 - Install and Configure Ardupilotblue:

Initialize the BeagleBone Blue, and install ardupilot using this tutorial. There are a lot of resources there, as well as this beginners guide.

Step 2 - Frame, Motors, and ESC:

Assemble your frame. You can use just about any frame, we picked this one because it's small and lightweight. Assembling the frame is straightforward. Just make sure if there's something electrical that's going sitting on carbon fiber, you insulate it. We ran into that issue a few times. As far as motors are concerned, make sure you know what type of frame you're flying with. Ours is an H, so we configured it according to the chart found here.

There is a difference between X and H in how the autopilot will react

Mounting the motors could be done after our ESCs were calibrated. We used these settings:

Programming card

Because we're using a battery monitor instead of having the drone land on it's own when the battery gets low. Simply power the card and ESC and it will make a happy chirp when it's finished.

We powered the ESCs by soldering the wires to a distribution board. That board also had a regulator to step down to 5V, which we used to power the BeagleBone Blue and the RC receiver.

One thing to note is that since our frame has the back motors mounted upside down, technically, the back two motors are switched. Use threadlocker to make sure the motor mounts won't wiggle out.

Notice the gold arrows on the motors point inwards

Once the motors and ESCs are mounted, you can test them with the throttle on the RC receiver (outputting a PWM signal), just to test it out.

Step 3 - RC to BeagleBone:

By default, the receiver will output a PWM, on multiple channels. We need a PPM signal to go into the BeagleBone Blue, which will in turn output four distinct PWM signals on different connectors.

The manual has the steps you need to take to reconfigure the receiver, but you re-pair the receiver with a jumper on to set it on PPM mode. That PPM signal goes to E4, pin 4.

The rightmost port on this picture

Example picture from ardupilotblue Github

Our connecton

We didn't have the connector to fit, and it wouldn't ship in time before we wanted to fly. Instead, we removed the connector and soldered it to the pad. Yes it worked. No you should not follow in our footsteps. Just order the connector.

After that just plug in the proper motors into the labeled PWM connectors and you're almost ready to fly.

Step 4 - Preflight:

Mount the propellers good and tight. For our specific motors, the included locknut didn't seen like it wanted to fit, but it did. Make sure the motors are spinning in the right direction, and the propellers are not installed backwards. There's a difference between CCW and CW.

Install Mission Planner - this communicates telemetry over WiFi between the BeagleBone Blue and your laptop. Before you try to arm and fly the drone, you'll want to dive into the Initial Setup (once you're connected).

Select your frame time, calibrate the level and accelerometer, as well as compass and radio.

Calibration is Key

Once that is complete, go into Config/Tuning, Standard Prarams. If you don't uncheck things like GPS (which isn't installed), it will never get off the ground.

This is what I have it check for before it can arm

You might run into the error that RC minimum is less than trim. If that's the case, dive into the Full Parameter Tree and change it manually.

The next step is to configure the PID gains, The defaults were way off, which made the drone lean and wobble a lot.

These were the values that ended up working for us.

If these don't work, feel free to experiment. some values are below the minimum, you can override by using the Full Parameter List/Tree.

Step 5 - First Flight and Leash:

From here, you can fly the drone as normal. All that's left is to mount the joystick to the frame, and attach the outputs to the ADC inputs. We again did not have the connector for it, so the wires are soldered to pads.

There is also a GND pin taken from a different spot on the board due to how close the pins are

The leash is mounted to the joystick with epoxy, and it quite firmly attached.

The wires on the side go to the ADC channels

We set up a switch on our controller to toggle between three different modes.

Stabilize is where the drone launches. Then a switch is flipped to put us into altitude hold. Finally, once we're confident with the position, we can put it into Guided Mode with another flip of the switch. If the python script is running, it will provide Mavlink commands based on the joystick position to set the attitude, which the guided mode uses.

Final Pictures

Battery is mounted in the middle RC receiver in the front (the antenna at the bottom)

Battery alarm at the back

ESCs are mounted on the arms with zipties

The black Velcro covers the barometer making it less susceptible to gusts of wind

Notes

If you want to use a GPS module, you can. That would make holding altitude a little easier and relying on the barometer.
Setting the python script to run at start will save you from having to SSH in and launch it manually. We never did that since it only took an extra 2 minutes.
Feel free to play around with the code!

leash.py

#!/usr/bin/env python3

import sys
import time
import Adafruit_BBIO.ADC as ADC
import math
from dronekit import connect, VehicleMode

"""
##Set up these values before flying!!!!
"""
run = 1
setpoint_x = 50
setpoint_y = 0
setpoint = [setpoint_x, setpoint_y]
Kp = 0.1
Ki = 0
Kd = 0
integral = [0.0, 0.0]
error_prior = [0.0, 0.0]
iteration_time = .1
current = [0, 0]
bias = 0
hover_thrust = 0.5

try:
	ADC.setup()
except:
	print("ADC Setup")

tcp_link = 'tcp:127.0.0.1:12345'

try:
	vehicle = connect(tcp_link)
	print("mavlink connection successful! tcp link: " + tcp_link)
	run = 1
except:
	print(" \n \nmavlink connection failed! \n \n")
	run = 0

# wait for vehicle attitude information to become available
while vehicle.attitude.yaw is None:
	time.sleep(.5)
# save initial yaw to use as target
target_yaw = math.degrees(vehicle.attitude.yaw)

# convert euler angles to quaternion to send over mavlink
# credit dronekit example: https://github.com/dronekit/dronekit-python/blob/master/examples/set_attitude_target/set_attitude_target.py
def to_quaternion(roll = 0.0, pitch = 0.0, yaw = 0.0):
	t0 = math.cos(math.radians(yaw * 0.5))
	t1 = math.sin(math.radians(yaw * 0.5))
	t2 = math.cos(math.radians(roll * 0.5))
	t3 = math.sin(math.radians(roll * 0.5))
	t4 = math.cos(math.radians(pitch * 0.5))
	t5 = math.sin(math.radians(pitch * 0.5))

	w = t0 * t2 * t4 + t1 * t3 * t5
	x = t0 * t3 * t4 - t1 * t2 * t5
	y = t0 * t2 * t5 + t1 * t3 * t4
	z = t1 * t2 * t4 - t0 * t3 * t5
	return [w, x, y, z]

try:
	while run:
		# read joystick values 0-100
		try:
			x_val = 100*ADC.read("AIN1")
			y_val = 100*ADC.read("AIN3")
			current = [x_val, y_val]
		except:
			print("ADC Values not Found!")
		print(current)
		
		# calculate PID
		error = [a_i - b_i for a_i, b_i in zip(setpoint, current)]
		integral = [a_i + (b_i * iteration_time) for a_i, b_i in zip(integral, error)]
		derivative = [(a_i - b_i) / iteration_time for a_i, b_i in zip(error, error_prior)]
		output = [Kp*a_i + Ki*b_i + Kd*c_i + bias for a_i, b_i, c_i in zip(error, integral, derivative)]
		
		# generate mavlink message to send attitude setpoint
		new_quat = to_quaternion(output[0], output[1], target_yaw)
		# http://ardupilot.org/dev/docs/copter-commands-in-guided-mode.html#copter-commands-in-guided-mode-set-attitude-target
		msg = vehicle.message_factory.set_attitude_target_encode(
			0, # time_boot_ms
			1, # target system
			1, # target component
			0b00000100,
			new_quat, # attitude (quaternion)
			0, # roll rate
			0, # pitch rate
			0, # yaw rate
			hover_thrust  # thrust (0-1 where 0.5 is no vertical velocity)
		)
		vehicle.send_mavlink(msg)

		time.sleep(iteration_time)
except KeyboardInterrupt:
	print('exiting')
	pass

vehicle.close()

Drone on a Leash