def requestSITL(self, lat, lon):
for i in range(len(self.drone_list)):
if self.drone_list[i][0] == None:
fo = open("logs/{:%Y-%m-%d..%H.%M.%S}..{}.txt".format(datetime.datetime.now(),i), "w")
self.drone_list[i][2] = fo
start_lat = 41.833474
start_lon = -87.626819
import dronekit_sitl
sitl = dronekit_sitl.start_default(start_lat, start_lon)
address = sitl.connection_string()
self.drone_list[i][0] = drone.Drone(address, lat, lon, altitude=10, output=fo)
return i
return -1
def __init__(self):
QtGui.QMainWindow.__init__(self)
# UI created by QT Designer
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# default value = 5 m
self.launchAlt = 5
#Set up option parsing to get connection string
import argparse
parser = argparse.ArgumentParser(description='Tracks GPS position of your computer (Linux only). Connects to SITL on local PC by default.')
parser.add_argument('--connect', help="vehicle connection target.")
args = parser.parse_args()
self.connection_string = args.connect
self.sitl = None
#Start SITL if no connection string specified
if not self.connection_string:
import dronekit_sitl
self.sitl = dronekit_sitl.start_default()
self.connection_string = self.sitl.connection_string()
# Connect to the Vehicle
print 'Connecting to vehicle on: %s' % self.connection_string
self.vehicle = connect(self.connection_string, wait_ready=True)
# Display Flight Mode
self.updateFlightModeGUI(self.vehicle.mode)
self.addObserverAndInit(
'mode'
,lambda vehicle,name,mode: self.updateFlightModeGUI(mode) )
# Display Location Info
self.updateLocationGUI(self.vehicle.location)
self.addObserverAndInit(
'location'
,lambda vehicle, name, location: self.updateLocationGUI(location) )
import sys
import wave
from communication import Communication
# Connect to xBee
COM_CONNECTION_STRING = '/dev/ttyUSB0' #potential option
com = Communication(COM_CONNECTION_STRING, 0.1)
# This block of code connects to the UAV over its serial connection, Pi -> PixHawk
# It also initalizes the vehicle object referenced throughout this file.
# When the connection information is known, fill out the portInformation variable to disable auto-start of SITL.
portInformation = '/dev/ttyAMA0' #'127.0.0.1:14550'
testSITL = None
if not portInformation:
testSITL = dronekit_sitl.start_default()
portInformation = testSITL.connection_string()
print ("Starting SITL Test Environment, No UAV Detected")
#file = open("test.txt", "w+")
#file.write("running")
#file.close()
time.sleep(30)
print("Connecting to UAV.")
UAV = connect(portInformation, wait_ready=True, baud=57600)
print(" Autopilot Firmware version: %s" % UAV.version)
# wait for radio transmission from ground station UI, store transmitted values into this array
# 0-1 are ISU 1 lat/long, 2-3 ISU 2 lat/long, 4-5 gnd station lat/long
# these default coordinates are locations around Palmer Park's drone field, and are default locations the drone can go to if communications fails
# SAFETY NOTE: DON'T MESS UP YOUR COORDINATES. EVEN AN ERROR IN THE TENTH'S PLACE CAN SEND THE DRONE MILES AWAY
import dronekit_sitl
from time import sleep
if __name__ == '__main__':
sitl = dronekit_sitl.start_default(lat=38.145206, lon=-76.428473)
print("Connection String:", sitl.connection_string())
try:
while True:
sleep(1)
except:
sitl.stop()
import dronekit_sitl sitl = dronekit_sitl.start_default(20.735517, -103.457499) from dronekit import connect, VehicleMode, LocationGlobalRelative import time
messages = position_messages_from_tlog(args.tlog)
print(" Generated %d waypoints from tlog" % len(messages))
if len(messages) == 0:
print("No position messages found in log")
exit(0)
#Start SITL if no connection string specified
if args.connect:
connection_string = args.connect
sitl = None
else:
start_lat = messages[0].lat/1.0e7
start_lon = messages[0].lon/1.0e7
import dronekit_sitl
sitl = dronekit_sitl.start_default(lat=start_lat,lon=start_lon)
connection_string = sitl.connection_string()
# Connect to the Vehicle
print('Connecting to vehicle on: %s' % connection_string)
vehicle = connect(connection_string, wait_ready=True)
# Now download the vehicle waypoints
cmds = vehicle.commands
cmds.wait_ready()
cmds = vehicle.commands
cmds.clear()
for pt in messages:
if len(sys.argv) != 5:
print "Incorrect number of arguments, invoke this script with: \n \
python launch.py adressname target-latitude target-longitude flag. \n \
Addressname of sitl will run it in a simulation \n \
If flag is 1, a new terminal will be created, if it is 0, it will run on the open terminal"
sys.exit()
if sys.argv[4] == "1":
subprocess.Popen("python launch.py %s %s %s 0" %
(sys.argv[1], sys.argv[2], sys.argv[3]),
creationflags=subprocess.CREATE_NEW_CONSOLE)
sys.exit()
address = sys.argv[1]
lat = float(sys.argv[2])
lon = float(sys.argv[3])
if address == "sitl":
start_lat = 41.833474
start_lon = -87.626819
import dronekit_sitl
sitl = dronekit_sitl.start_default(start_lat, start_lon)
address = sitl.connection_string()
d = drone.Drone(address, lat, lon)
d.connect()
d.run()
d.wait()
d.close()
def build_simulated_connect(self):
import dronekit_sitl
sitl = dronekit_sitl.start_default()
self.connection_string = sitl.connection_string()
messages = position_messages_from_tlog(args.tlog)
print(" Generated %d waypoints from tlog" % len(messages))
if len(messages) == 0:
print("No position messages found in log")
exit(0)
#Start SITL if no connection string specified
if args.connect:
connection_string = args.connect
sitl = None
else:
start_lat = messages[0].lat / 1.0e7
start_lon = messages[0].lon / 1.0e7
import dronekit_sitl
sitl = dronekit_sitl.start_default(lat=start_lat, lon=start_lon)
connection_string = sitl.connection_string()
# Connect to the Vehicle
print('Connecting to vehicle on: %s' % connection_string)
vehicle = connect(connection_string, wait_ready=True)
# Now download the vehicle waypoints
cmds = vehicle.commands
cmds.wait_ready()
cmds = vehicle.commands
cmds.clear()
for pt in messages:
#print "Point: %d %d" % (pt.lat, pt.lon,)
lat = pt.lat
def quick_scan_autonomy(configs, autonomyToCV, gcs_timestamp,
connection_timestamp):
print(
"\n######################## STARTING QUICK SCAN AUTONOMY ########################"
)
autonomy.configs = configs
# If comms is simulated, start comm simulation thread
if configs["quick_scan_specific"]["comms_simulated"]["toggled_on"]:
comm_sim = Thread(target=comm_simulation,
args=(
configs["quick_scan_specific"]["comms_simulated"]
["comm_sim_file"],
xbee_callback,
))
comm_sim.start()
# Otherwise, set up XBee device and add callback
else:
comm_sim = None
autonomy.xbee = setup_xbee()
autonomy.gcs_timestamp = gcs_timestamp
autonomy.connection_timestamp = connection_timestamp
autonomy.xbee.add_data_received_callback(xbee_callback)
# Generate waypoints after start_mission = True
while not autonomy.start_mission:
pass
# Generate waypoints
waypoints = generate_waypoints(configs, search_area)
# Start SITL if vehicle is being simulated
if (configs["vehicle_simulated"]):
import dronekit_sitl
sitl = dronekit_sitl.start_default(lat=35.328423, lon=-120.752505)
connection_string = sitl.connection_string()
else:
if (configs["3dr_solo"]):
connection_string = "udpin:0.0.0.0:14550"
else:
connection_string = "/dev/serial0"
# Connect to vehicle
vehicle = connect(connection_string, wait_ready=True)
# Starts the update thread
update = Thread(target=update_thread,
args=(vehicle, configs["mission_control_MAC"]))
update.start()
# Send mission to vehicle
quick_scan_adds_mission(vehicle, waypoints[1], configs["altitude"])
# Start the mission
start_auto_mission(vehicle)
# Change vehicle status to running
change_status("running")
# Fly about spiral pattern
while vehicle.commands.next != vehicle.commands.count:
print(vehicle.location.global_frame)
time.sleep(1)
# Holds the copter in place if receives pause
if autonomy.pause_mission:
vehicle.mode = VehicleMode("ALT_HOLD")
# Lands the vehicle if receives stop mission
elif autonomy.stop_mission:
land(vehicle)
return
# Continues path
else:
vehicle.mode = VehicleMode("AUTO")
# Switch to detailed search if role switching is enabled
if configs["quick_scan_specific"]["role_switching"]:
autonomy.mission_completed = True
update.join()
detailed_search(vehicle)
else:
land(vehicle)
# Ready for a new mission
autonomy.mission_completed = True
# Wait for update thread to end
update.join()
# Wait for comm simulation thread to end
if comm_sim:
comm_sim.join()
else:
autonomy.xbee.close()
def main():
#vehicle = connect('/dev/serial0', wait_ready=False, baud=57600)
import dronekit_sitl
sitl = dronekit_sitl.start_default()
connection_string = sitl.connection_string()
vehicle = connect(
connection_string,
wait_ready=False,
)
# NOTE these are *very inappropriate settings*
# to make on a real vehicle. They are leveraged
# exclusively for simulation. Take heed!!!
vehicle.parameters['FS_GCS_ENABLE'] = 0
vehicle.parameters['FS_EKF_THRESH'] = 100
arm_and_takeoff(vehicle, 10)
# navigate to video and log files.
filestring = r"../../../Landing_Tests/7-18-18 landing vids"
fileDir = os.path.dirname(os.path.realpath('__file__'))
dataDir = os.path.join(fileDir, filestring)
dataDir = os.path.abspath(os.path.realpath(dataDir))
fileNames = os.listdir(dataDir)
vidNames = [f for f in fileNames if f.endswith('.avi')]
vidfilepath = os.path.join(dataDir, vidNames[1]) # select fourth video
# start input video stream
#vs = PiVideoStream(resolution=(og_horz_resolution, og_vert_resolution)).start()
# vs.read() returns a tuple. I want the second item, Item 1. I want to dynamically replace every instance of vs.read() with vs.read()[1]. How do I override that function? With this class.
class vidstream_wrapper():
def __init__(self, vs):
self.vs = vs
def read(self):
return self.vs.read()[1]
vs = vidstream_wrapper(cv2.VideoCapture(vidfilepath))
# wait for the camera to start
time.sleep(0.5)
fps = getFPS(vs, vehicle)
# label this capture
start_time = datetime.datetime.now().replace(
microsecond=0).strftime('%y-%m-%d %H.%M.%S')
# Define the codec and create VideoWriter object
fourcc = cv2.cv.CV_FOURCC(*'DIVX')
video_file = "Captures/camera_cap_" + start_time + ".avi"
out = cv2.VideoWriter(video_file, fourcc, fps.fps(),
(horizontal_resolution, vertical_resolution))
# Make Log headers
log_name = 'Log/Bot_' + start_time + '.txt'
make_headers(log_name)
# control loop
state = Restart_State()
while (repr(state) != "Landed_State"):
try:
# show frame. Note: this destroys a frame.
frame = vs.read()
cv2.imshow('frame', frame)
if cv2.waitKey(10) & 0xFF == ord('q'):
break
state.executeControl(vs, vehicle, out, log_name)
state = state.transition()
except (KeyboardInterrupt, SystemExit):
break
terminate_flight(vehicle)
out.release()
vehicle.close()
cv2.destroyAllWindows()
vs.stop()
import dronekit_sitl
from time import sleep
if __name__ == '__main__':
sitl = dronekit_sitl.start_default(lat=38.870604, lon=-77.322292)
print("Connection String:", sitl.connection_string())
try:
while True:
sleep(1)
except:
sitl.stop()
def connectmycopter():
import dronekit_sitl
sitl = dronekit_sitl.start_default()
connection_string = sitl.connection_string()
vehicle = connect(connection_string, wait_ready=True)
return vehicle
# Importing appropriate libraries
from dronekit import connect, VehicleMode, LocationGlobalRelative
import time
import math
# Set up option parsing to get connection string
import argparse
parser = argparse.ArgumentParser(description='commands')
parser.add_argument('--connect')
args = parser.parse_args()
connection_string = args.connect
# Start SITL if no connection string specified
if not connection_string:
import dronekit_sitl
sitl = dronekit_sitl.start_default(wp0lat, wp0long)
connection_string = sitl.connection_string()
# Connect to the Vehicle
print("connection to the vehicle on %s" % connection_string)
vehicle = connect(connection_string, wait_ready=True)
# Allow time for the mission planner to download parameters
time.sleep(10)
#### Define Functions ####
# Define the function for arm and takeoff
def arm_and_takeoff(aTargetAltitude):
"""
lat, lng = position.offset(heading, distance_as_km).to_string('D')
return (float(lat), float(lng))
def do_camera(self, args):
''' trigger camera to capture a photo '''
# check vehicle status and mode
console.white('... capturing image')
self.vehicle.trigger_camera()
self._wait() # wait 3 seconds for clean shot
console.blank()
if __name__ == '__main__':
# check for the --test flag from the command line
test = True if '--test' in ' '.join(sys.argv) else False
# if running in test mode, start the simulator in another process
if test:
sitl = dronekit_sitl.start_default(lat=41.9751961, lon=-87.6636616)
# enter the console application
app = App(test=test)
app.cmdloop()
# if running in test mode, end the simulator before finishing
if test:
sitl.stop()
import time
from dronekit import connect, VehicleMode, LocationGlobalRelative, Command, LocationGlobal
#import RPi.GPIO as GPIO
import dronekit_sitl
from pymavlink import mavutil
#Arm and Takeoff.
sitl = dronekit_sitl.start_default(20.737641, -103.457018)
connection_string = sitl.connection_string
def arm_and_takeoff(TargetAltitude):
#Vehicle Connection
print("Executing Takeoff")
while not drone.is_armable:
print("Vehicle is not armable, waiting...")
time.sleep(1)
print("Ready to arm")
drone.mode = VehicleMode("GUIDED")
drone.armed = True
while not drone.armed:
print("Waiting for arming...")
time.sleep(1)
print("Ready for takeoff, taking off...")
drone.simple_takeoff(TargetAltitude)
import dronekit as dk
import dronekit_sitl as dk_sitl
import time
print "Start simulator (SITL)"
sitl = dk_sitl.start_default()
connect_string = sitl.connection_string()
# Exception to throw in the event of a failed connection
class NoConnectionError(Exception):
def __init__(self):
Exception.__init__(self)
# Drone Autopilot Class
class DronePilot:
# Constructor Method
def _init__(self):
self.connect_string = None
self.drone = None
# Method to initiate drone connection
def connect(self,connect_string):
import dronekit_sitl
from dronekit import connect, VehicleMode
# Connection
try:
print("Connecting to vehicle on '/dev/ttyACM0'")
vehicle = connect('/dev/ttyACM0', wait_ready=True, baud=57600)
sitl = False
except:
print("Can't connect to physical vehicle.")
print("Starting simulated vehicle.")
sitl = dronekit_sitl.start_default() # Simulator
connection_string = sitl.connection_string()
print("Connecting to vehicle on {}".format(connection_string))
vehicle = connect(connection_string, wait_ready=True)
print("Get some vehicle attributes (state):")
print("Autopilot Firmware version: %s" % vehicle.version)
print("Autopilot capabilities (supports ftp): %s" % vehicle.capabilities.ftp)
print("Global Location: %s" % vehicle.location.global_frame)
print("Global Location (relative altitude): %s" %
vehicle.location.global_relative_frame)
print("Local Location: %s" % vehicle.location.local_frame)
print("Attitude: %s" % vehicle.attitude)
print("Velocity: %s" % vehicle.velocity)
print("GPS: %s" % vehicle.gps_0)
print("Groundspeed: %s" % vehicle.groundspeed)
print("Airspeed: %s" % vehicle.airspeed)
print("Gimbal status: %s" % vehicle.gimbal)
print("Waiting for arming..")
time.sleep(1)
print("Taking off!")
vehicle.simple_takeoff(aTargetAltitude)
# Wait until the vehicle reaches a safe height before processing the goto
# (otherwise the command after Vehicle.simple_takeoff will execute inmediately).
while True:
print(" Altitude: ", vehicle.location.global_relative_frame.alt)
# Break and return from function just below target altitude.
if vehicle.location.global_relative_frame.alt >= aTargetAltitude * 0.95:
print("Reached target altitude")
break
time.sleep(1)
if __name__ == "__main__":
sitl = dronekit_sitl.start_default() # basic ArduCopter simulator
connection_string = sitl.connection_string()
print("Connecting to vehicle on {}".format(connection_string))
vehicle = connect(connection_string, wait_ready=True)
# Start mission
point1 = LocationGlobalRelative(-35.361354, 149.165218, 20)
point2 = LocationGlobalRelative(-35.363244, 149.168801, 20)
mission(20, 5, [point1, point2], [7, 10], True)
sitl.stop() # Stop simulation
parser = argparse.ArgumentParser(
description='Commands vehicle using vehicle.simple_goto.')
parser.add_argument(
'--connect',
help=
"Vehicle connection target string. If not specified, SITL automatically started and used."
)
args = parser.parse_args()
connection_string = args.connect
sitl = None
# Start SITL if no connection string specified
if not connection_string:
import dronekit_sitl
sitl = dronekit_sitl.start_default(24.180956, 120.649184)
connection_string = sitl.connection_string()
# Connect to the Vehicle
print('Connecting to vehicle on: %s' % connection_string)
# print("(Connecting to vehicle on: /dev/ttyAMA0)")
# vehicle = connect('/dev/ttyAMA0', wait_ready=True, baud=57600)
vehicle = connect(connection_string, wait_ready=True, baud=921600)
# Function to arm and then takeoff to a user specified altitude
def arm_and_takeoff(aTargetAltitude):
"""
Arms vehicle and fly to aTargetAltitude.
"""
print("\n Basic pre-arm checks")
#first we new to connect to apm with cmd or terminal using the next commands.
#this command is to make the drone house insede the campus #dronekit-sitl copter --home=20.7377382,-103.4570051,1357,180
#then we need to make the connection with #mavproxy.py --master tcp:127.0.0.1:5760 --out udp:127.0.0.1:14551 --out udp:10.43.14.246:14550
#this is a group of codes that are already givven by dronekit in this case
import time
from dronekit import connect, VehicleMode, LocationGlobalRelative
from pymavlink import mavutil
import Tkinter as tk
import dronekit_sitl
sitl = dronekit_sitl.start_default(20.735892, -103.457091)
connection_string = sitl.connection_string
def arm_and_takeoff(TargetAltitude):
#Vehicle connection
print("Executing Takeoff")
#At this part our drone is not ready to arm. we give him the order to don't armed yet.
while not drone.is_armable:
print("Vehicle is not armable, waiting...")
time.sleep(1)
#When the drone is also ready he is going to tell us that is ready to arm and start the guided mode that is guided by coordenates.
print("Ready to arm")
drone.mode = VehicleMode("GUIDED")
drone.armed = True
#Sometimes the drone take more time to be ready. So in line 21-24 our drone will tell us he is taking more time to be ready to arm
while not drone.armed:
print("waiting for arming...")
time.sleep(1)
#note:time.sleep(x) is the time in seconds that the program is going to stop.
#When the drone finished all the steps before he is going to tell us. The drone will start to fly at this point and he is going to reach an altitude that we decide to.
def __init__(self):
sitl = dronekit_sitl.start_default()
connection_string = sitl.connection_string()
vehicle = connect(connection_string, wait_ready=True)
print("!!! Connection to the vehicle on: {} !!!".format(connection_string))
import dronekit_sitl
from time import sleep
"""
runs dronekit which is necessary for connecting to the Mission planner simulator.
"""
if __name__ == '__main__':
sitl = dronekit_sitl.start_default(lat=29.867295, lon=77.898946)
print("Connection String:", sitl.connection_string())
try:
while True:
sleep(1)
except:
sitl.stop()
parser = argparse.ArgumentParser(
description='Commands vehicle using vehicle.simple_goto.')
parser.add_argument(
'--connect',
help=
"Vehicle connection target string. If not specified, SITL automatically started and used."
)
args = parser.parse_args()
connection_string = args.connect
sitl = None
#Start SITL if no connection string specified
if not connection_string:
import dronekit_sitl
sitl = dronekit_sitl.start_default()
connection_string = sitl.connection_string()
# Connect to the Vehicle
print('Connecting to vehicle on: %s' % connection_string)
vehicle = connect(connection_string,
wait_ready=True,
baud=57600,
heartbeat_timeout=120)
def arm_and_takeoff(aTargetAltitude):
"""
Arms vehicle and fly to aTargetAltitude.
"""
def startProtocol(self):
try:
print "Started application"
print "Init dronekit object"
#connection_string = None
#connection_string = 'com3' #window
#connection_string = '/dev/cu.usbmodem1' #macos
connection_string = '/dev/ttyACM0' #ubuntu
sitl = None
#Start SITL if no connection string specified
if not connection_string:
import dronekit_sitl
sitl = dronekit_sitl.start_default()
connection_string = sitl.connection_string()
#Connect to vehicle
print '\nConnecting to vehicle on: %s' % connection_string
vehicle = connect(connection_string, wait_ready=True, baud=57600)
vehicle.wait_ready('autopilot_version')
self.vehicle = vehicle
#init pixhaw obj
self.pho = BaseJsonObj()
self.pho.Vehicle = {
'Velocity': self.vehicle.velocity,
'Heading': self.vehicle.heading,
'Battery': {
'Voltage': self.vehicle.battery.voltage,
'Current': self.vehicle.battery.current,
'Level': self.vehicle.battery.level
}
}
self.pho.LocationGlobal = {
'Lat': self.vehicle.location.global_frame.lat,
'Lon': self.vehicle.location.global_frame.lon,
'Alt': self.vehicle.location.global_frame.alt
}
self.pho.GpsInfo = {
'Eph': self.vehicle.gps_0.eph,
'Epv': self.vehicle.gps_0.epv,
'Fix_Type': self.vehicle.gps_0.fix_type,
'Satellites_Visible': self.vehicle.gps_0.satellites_visible,
}
self.pho.SystemStatus = {'State': self.vehicle.system_status.state}
self.pho.Attitude = {
'Yaw': self.vehicle.attitude.yaw,
'Pitch': self.vehicle.attitude.pitch,
'Roll': self.vehicle.attitude.roll
}
#mapping attribute change
self.vehicle.add_attribute_listener('velocity',
self.velocity_callback)
self.vehicle.add_attribute_listener('battery',
self.battery_callback)
self.vehicle.add_attribute_listener('gps_0', self.gps0_callback)
self.vehicle.add_attribute_listener('location.global_frame',
self.location_callback)
self.vehicle.add_attribute_listener('system_status',
self.status_callback)
self.vehicle.add_attribute_listener('heading',
self.heading_callback)
self.vehicle.add_attribute_listener('attitude',
self.attitude_callback)
print 'started GNU thread'
gnuThread.start()
except [[KeyboardInterrupt]]:
usrb_object.stop()
self.vehicle.remove_attribute_listener('velocity',
self.velocity_callback)
self.vehicle.remove_attribute_listener('battery',
self.battery_callback)
self.vehicle.remove_attribute_listener('gps_0', self.gps0_callback)
self.vehicle.remove_attribute_listener('location.global_frame',
self.location_callback)
self.vehicle.remove_attribute_listener('system_status',
self.status_callback)
self.vehicle.remove_attribute_listener('heading',
self.heading_callback)
self.vehicle.remove_attribute_listener('attitude',
self.attitude_callback)
self.vehicle.close()
pass
import drone
import subprocess
if len(sys.argv) != 5:
print ("Incorrect number of arguments, invoke this script with: \n \
python launch.py adressname target-latitude target-longitude flag. \n \
Addressname of sitl will run it in a simulation \n \
If flag is 1, a new terminal will be created, if it is 0, it will run on the open terminal")
sys.exit()
if sys.argv[4] == "1":
subprocess.Popen("python launch.py %s %s %s 0" % (sys.argv[1], sys.argv[2], sys.argv[3]), creationflags = subprocess.CREATE_NEW_CONSOLE)
sys.exit()
address = sys.argv[1]
lat = float(sys.argv[2])
lon = float(sys.argv[3])
if address == "sitl":
start_lat = 41.833474
start_lon = -87.626819
import dronekit_sitl
sitl = dronekit_sitl.start_default(start_lat, start_lon)
address = sitl.connection_string()
d = drone.Drone(address, lat, lon)
d.connect()
d.run()
d.wait()
d.close()
import argparse
parser = argparse.ArgumentParser(description='Print out vehicle state information. Connects to SITL on local PC by default.')
parser.add_argument('--connect',
help="vehicle connection target string. If not specified, SITL automatically started and used.")
args = parser.parse_args()
sitl = None
connection_string = '127.0.0.1:14551'
HOST = '127.0.0.1' # The server's hostname or IP address
PORT = 65432 # The port used by the server
#Start SITL if no connection string specified
if not connection_string:
import dronekit_sitl as sim
sitl = sim.start_default()
connection_string = sitl.connection_string()
print("\nConnecting to vehicle on: %s" % connection_string)
vta = connect(connection_string, wait_ready=False, baud=57600, heartbeat_timeout=180)
vta.wait_ready('autopilot_version')
print("\nConnected to: %s" % connection_string)
#float tetherLength=
def arm(vehicle):
"""
Arms vehicle.
# To create and start simulators of copter
sitl = None
if args.sitl:
sitls = []
cnt_strs = []
def connect_to_monitor(h, p, idx):
sitls[idx - 1][0].launch(sitls[idx - 1][1], await_ready=True)
vehicle = connect_vehicle(cnt_strs[idx - 1])
vehicle.groundspeed = speed
sitls[idx - 1] = drone.Drone(vehicle, h, p, idx)
# Preparation for starting multiple separated simulators
from dronekit_sitl import SITL, start_default
if args.sitl == 1:
sitl = start_default(args.lat, args.lon)
connection_string = sitl.connection_string()
vehicle = connect_vehicle(connection_string)
mav = drone.Drone(vehicle, host, port)
mav.set_speed(speed)
else:
for i in range(0, args.sitl):
sitl = SITL()
sitl.download('copter', '3.3', verbose=True)
sitl_args = [
'-I%d' % i, '--model', 'quad',
'--home=%f,%f,584,353' % (args.lat, args.lon + 5e-5 * i)
]
sitls.append([sitl, sitl_args])
cnt_strs.append('tcp:127.0.0.1:%d' % (5760 + 10 * i))
c = Thread(target=connect_to_monitor,
def detailed_search_autonomy(configs, autonomyToCV, gcs_timestamp, connection_timestamp, vehicle=None):
print("\n######################## STARTING DETAILED SEARCH AUTONOMY ########################")
autonomy.configs = configs
# If comms is simulated, start comm simulation thread
if configs["detailed_search_specific"]["comms_simulated"]["toggled_on"]:
comm_sim = Thread(target=comm_simulation, args=(configs["detailed_search_specific"]["comms_simulated"]["comm_sim_file"], xbee_callback,))
comm_sim.start()
# Otherwise, set up XBee device and add callback
else:
comm_sim = None
autonomy.xbee = setup_xbee()
autonomy.gcs_timestamp = gcs_timestamp
autonomy.connection_timestamp = connection_timestamp
autonomy.xbee.add_data_received_callback(xbee_callback)
# If detailed search was not role-switched from quick scan, connect to new vehicle and takeoff
if not vehicle:
# Start SITL if vehicle is being simulated
if (configs["vehicle_simulated"]):
import dronekit_sitl
sitl = dronekit_sitl.start_default(lat=35.328423, lon=-120.752505)
connection_string = sitl.connection_string()
else:
if (configs["3dr_solo"]):
connection_string = "udpin:0.0.0.0:14550"
else:
connection_string = "/dev/serial0"
# Connect to vehicle
vehicle = connect(connection_string, wait_ready=True)
# Starts the update thread
update = Thread(target=update_thread, args=(vehicle, configs["mission_control_MAC"]))
update.start()
takeoff(vehicle, configs["altitude"])
else:
# Starts the update thread
update = Thread(target=update_thread, args=(vehicle, configs["mission_control_MAC"]))
update.start()
# Change vehicle status to running
change_status("running")
# Continuously fly to POIs
while not autonomy.stop_mission:
if not POI_queue.empty() and not autonomy.pause_mission:
poi = POI_queue.get()
poi.alt = configs["altitude"]
vehicle.simple_goto(poi)
print("At POI, now orbiting")
# TODO start CV scanning
orbit_poi(vehicle, poi, configs)
# Change flight mode to AUTO to start auto mission
vehicle.mode = VehicleMode("AUTO")
# print location while orbiting
while vehicle.commands.next != vehicle.commands.count:
print(vehicle.location.global_frame)
print(vehicle.commands.next)
print(vehicle.commands.count)
time.sleep(1)
# TODO stop CV scanning
# Change flight mode back
vehicle.mode = VehicleMode("GUIDED")
else:
change_status("waiting")
# Holds the copter in place if receives pause
if autonomy.pause_mission:
vehicle.mode = VehicleMode("ALT_HOLD")
change_status("paused")
# Otherwise continue
else:
vehicle.mode = VehicleMode("GUIDED")
land(vehicle)
# Sets vehicle status to "ready"
change_status("ready")
autonomy.mission_completed = True
update.join()
# Wait for comm simulation thread to end
if comm_sim:
comm_sim.join()
else:
autonomy.xbee.close()
def ConnectToUAV(SimvReal):
while gbvar.UAVS == "":
while gbvar.uInputLaunch == "":
time.sleep(1)
print("Attempting Connection to SOLO")
print gbvar.uInputLaunch
if gbvar.uInputLaunch == "1":
parser = argparse.ArgumentParser(
description=
'Print out vehicle state information. Connects to SITL on local PC by default.'
)
parser.add_argument(
'--connect',
default='115200',
help="vehicle connection target. Default '57600'")
args = parser.parse_args()
gbvar.UAVS = connect(
'/dev/serial/by-id/usb-3D_Robotics_PX4_FMU_v2.x_0-if00',
baud=115200,
rate=6)
elif gbvar.uInputLaunch == "0":
parser = argparse.ArgumentParser(
description=
'Print out vehicle state information. Connects to SITL on local PC by default.'
)
parser.add_argument(
'--connect',
help=
"Vehicle connection target string. If not specified, SITL automatically started and used."
)
args = parser.parse_args()
import dronekit_sitl
sitl = dronekit_sitl.start_default()
connection_string = sitl.connection_string()
# Connect to the Vehicle
print 'Connecting to vehicle on: %s' % connection_string
gbvar.UAVS = connect(connection_string, wait_ready=True)
elif gbvar.uInputLaunch == "test":
parser = argparse.ArgumentParser(
description=
'Print out vehicle state information. Connects to SITL on local PC by default.'
)
parser.add_argument(
'--connect',
help=
"Vehicle connection target string. If not specified, SITL automatically started and used."
)
args = parser.parse_args()
import dronekit_sitl
sitl_c = dronekit_sitl.start_default()
connection_string_c = sitl_c.connection_string()
# manually specifying connection, due to some computer interferance.
# If running simulation using 2 computers, comment out the below line
connection_string_c = 'tcp:127.0.0.1:5763'
# Connect to the Vehicle
print 'Connecting to vehicle on: %s' % connection_string_c
gbvar.UAVS = connect(connection_string_c, wait_ready=True)
time.sleep(1)
print "Start simulator (SITL)"
import dronekit_sitl
sitl = dronekit_sitl.start_default()
connection_string = sitl.connection_string()
# Import DroneKit-Pythonpip install dronekit-sitl
from dronekit import connect, VehicleMode
# Connect to the Vehicle.
print("Connecting to vehicle on: %s" % (connection_string,))
vehicle = connect(connection_string, wait_ready=True)
# Get some vehicle attributes (state)
print "Get some vehicle attribute values:"
print " GPS: %s" % vehicle.gps_0
print " Battery: %s" % vehicle.battery
print " Last Heartbeat: %s" % vehicle.last_heartbeat
print " Is Armable?: %s" % vehicle.is_armable
print " System status: %s" % vehicle.system_status.state
print " Mode: %s" % vehicle.mode.name # settable
# Close vehicle object before exiting script
vehicle.close()
# Shut down simulator
sitl.stop()
print("Completed")
import dronekit as dk import time import dronekit_sitl as dks from mismeth import * import pymavlink as mav sitl = dks.start_default(52.9241747, -4.0542528) connection_string = sitl.connection_string() vehicle = dk.connect(connection_string, wait_ready=True) cmds = vehicle.commands cmds.download() cmds.wait_ready() alt = 4 loc1 = dk.LocationGlobalRelative(52.9243403, -4.0539125, alt) #loc1 = get_location_metres(vehicle.location.global_frame,50,50) loc2 = dk.LocationGlobalRelative(52.924303, -4.054105, alt) loc3 = dk.LocationGlobalRelative(52.924393, -4.0539249, alt) loc4 = dk.LocationGlobalRelative(52.9244998, -4.0537784, alt) vehicle.groundspeed = 15 arm_takeoff(vehicle, alt) vehicle.simple_goto(loc2) stay_in_range(vehicle, loc2) ####### TASK 2 AND TASK 3 ######## vehicle.simple_goto(loc3) stay_in_range(vehicle, loc3)