print("listening")
s.listen(5) # 接続待ち
c, addr = s.accept() # 接続要求の取り出し
c.settimeout(10)
bebop = Bebop(drone_type="Bebop2")
print("connecting to Bebop2")
success = bebop.connect(10)
print(success)
try:
if (success):
print("sleeping")
bebop.smart_sleep(2)
bebop.ask_for_state_update()
# set safe indoor parameters
bebop.set_max_tilt(5)
bebop.set_max_vertical_speed(1)
# trying out the new hull protector parameters - set to 1 for a hull protection and 0 without protection
bebop.set_hull_protection(1)
while True:
print("receiving")
ch = c.recv(4096).decode()
if ch == "t":
if __name__ == "__main__":
# make my mambo object
# remember to set True/False for the wifi depending on if you are using the wifi or the BLE to connect
# the address can be empty if you are using wifi
mambo = Bebop()
print("trying to connect to mambo now")
success = mambo.connect(num_retries=3)
print("connected: %s" % success)
if (success):
# get the state information
print("sleeping")
mambo.smart_sleep(1)
mambo.ask_for_state_update()
mambo.smart_sleep(1)
# setup the extra window to draw the markers in
cv2.namedWindow("ExampleWindow")
cv2.namedWindow("dst")
print("Preparing to open vision")
mambo.pan_tilt_camera_velocity(-90, 0, 1)
mamboVision = DroneVisionGUI(
mambo,
is_bebop=True,
buffer_size=200,
user_code_to_run=demo_mambo_user_vision_function,
user_args=(mambo, ))
class myoBebop(object):
def __init__(self , indoorFly = True):
'''类初始化函数'''
self.bebop = None
self.indoorFlyFlag = indoorFly
self.actionType = "rest" #当前的动作类型
self.startSuccessFlag = False #初始化是否成功标志位
self.takeOfFlag = False #是否起飞标志位
self.landFlag = True #是否降落标志位
self.startFlag = False #程序开始标志位
self.executeCommondFlag = True #命令执行成功标志位
#动作映射字典
self.actionMapDict = { "front" : "fist" , "back" : "open_hand" ,
"left" : "one" , "right" : "two" ,
"up" : "good", "down" : "low" ,
"rotateLeft" : "three" , "rotateRight" : "four" ,
"takeOf": "ok" , "land" : "love"}
self.tempCount = 0 #计数
self.excuteFlag1 = True #读取动作类别标志位
self.excuteFlag2 = True #读取按键值的标志位
self.flyType = 0 #飞机飞行类别（0：正常飞行 ， 1：特技飞行）
self.moveStepTime = 1 #飞行器水平运行步长时间
self.rotateStepTime = 1 #飞行器旋转运行步长时间
def start(self):
'''开始函数'''
#初始化飞机对象
self.bebop = Bebop()
#连接飞机
print("connecting")
self.success = self.bebop.connect(10) #与飞机进行连接（最大尝试次数为10次）
if self.success == True:
print("sleeping")
self.bebop.smart_sleep(5)
self.bebop.ask_for_state_update() #获取飞机的状态
if self.indoorFlyFlag == True:
self.setIndoorFly()
print("set indoor fly sucess!!!")
print("The aircraft was successfully initialized!")
self.startSuccessFlag = True #开始成功
else:
print("The connection failed. Please check again!")
self.startSuccessFlag = False #开始失败
self.removeExitFile()
def bebopFly(self , actionType):
'''根据动作类别进行相应的动作'''
if actionType == self.actionMapDict["front"]: #向前飞
self.executeCommondFlag = False
print("flying state is %s" % self.bebop.sensors.flying_state)
if self.flyType == 0:
self.bebop.fly_direct(roll=0, pitch=50, yaw=0, vertical_movement=0, duration=self.moveStepTime)
print("fly front")
elif self.flyType == 1:
self.success = self.bebop.flip(direction="front")
print("flip front")
print("mambo flip result %s" % self.success)
self.bebop.smart_sleep(5)
self.executeCommondFlag = True
elif actionType == self.actionMapDict["back"]: #向后飞
self.executeCommondFlag = False
print("flying state is %s" % self.bebop.sensors.flying_state)
if self.flyType == 0:
self.bebop.fly_direct(roll=0, pitch=-50, yaw=0, vertical_movement=0, duration=self.moveStepTime)
print("fly back")
elif self.flyType == 1:
self.success = self.bebop.flip(direction="back")
print("flip back")
print("mambo flip result %s" % self.success)
self.bebop.smart_sleep(5)
self.executeCommondFlag = True
elif actionType == self.actionMapDict["left"]: #左飞
self.executeCommondFlag = False
print("flying state is %s" % self.bebop.sensors.flying_state)
if self.flyType == 0:
self.bebop.fly_direct(roll=50, pitch=0, yaw=0, vertical_movement=0, duration=self.moveStepTime)
print("fly left")
elif self.flyType == 1:
self.success = self.bebop.flip(direction="left")
print("flip left")
print("mambo flip result %s" % self.success)
self.bebop.smart_sleep(5)
self.executeCommondFlag = True
elif actionType == self.actionMapDict["right"]: #右飞
self.executeCommondFlag = False
print("flying state is %s" % self.bebop.sensors.flying_state)
if self.flyType == 0:
self.bebop.fly_direct(roll=-50, pitch=0, yaw=0, vertical_movement=0, duration=self.moveStepTime)
print("fly right")
elif self.flyType == 1:
self.success = self.bebop.flip(direction="right")
print("flip right")
print("mambo flip result %s" % self.success)
self.bebop.smart_sleep(5)
self.executeCommondFlag = True
elif actionType == self.actionMapDict["up"]: #上飞
self.executeCommondFlag = False
print("flying state is %s" % self.bebop.sensors.flying_state)
if self.flyType == 0:
self.bebop.fly_direct(roll = 0, pitch = 0, yaw = 0, vertical_movement=50, duration = self.moveStepTime)
print("fly up")
elif self.flyType == 1:
pass
self.executeCommondFlag = True
elif actionType == self.actionMapDict["down"]: #下飞
self.executeCommondFlag = False
print("flying state is %s" % self.bebop.sensors.flying_state)
if self.flyType == 0:
self.bebop.fly_direct(roll = 0, pitch = 0, yaw = 0, vertical_movement= - 50, duration = self.moveStepTime)
print("fly down")
elif self.flyType == 1:
pass
self.executeCommondFlag = True
elif actionType == self.actionMapDict["rotateLeft"]: #向左旋转
self.executeCommondFlag = False
print("flying state is %s" % self.bebop.sensors.flying_state)
if self.flyType == 0:
self.bebop.fly_direct(roll=0, pitch=0, yaw=50, vertical_movement=0, duration=self.moveStepTime)
print("fly rotateLeft")
elif self.flyType == 1:
pass
self.executeCommondFlag = True
elif actionType == self.actionMapDict["rotateRight"]: #向右旋转
self.executeCommondFlag = False
print("flying state is %s" % self.bebop.sensors.flying_state)
if self.flyType == 0:
self.bebop.fly_direct(roll=0, pitch=0, yaw = -50, vertical_movement=0, duration=self.moveStepTime)
print("fly rotateRight")
elif self.flyType == 1:
pass
self.executeCommondFlag = True
elif actionType == self.actionMapDict["takeOf"]: #起飞
self.startFlag = True
if self.landFlag == True:
self.landFlag = False
self.executeCommondFlag = False
print("take of ")
self.bebop.safe_takeoff(10)
self.bebop.smart_sleep(5)
self.executeCommondFlag = True
self.takeOfFlag = True
elif actionType == self.actionMapDict["land"]: #降落
if self.takeOfFlag == True:
self.takeOfFlag = False
self.executeCommondFlag = False
print("land ")
self.bebop.safe_land(10)
self.bebop.smart_sleep(5)
self.landFlag = True
self.executeCommondFlag = True
#myo失去连接后，飞机自动着落
def safeAction(self):
if self.startFlag == True:
if self.flyType == 0:
if self.tempCount > 100:
self.bebop.safe_land(10)
self.bebop.smart_sleep(5)
print("DONE - disconnecting")
self.bebop.disconnect()
self.mThread.forcedStopThread()
elif self.flyType == 1:
if self.tempCount > 300:
self.bebop.safe_land(10)
self.bebop.smart_sleep(5)
print("DONE - disconnecting")
self.bebop.disconnect()
self.mThread.forcedStopThread()
def setTheActionMain(self):
'''设置动作类别线程函数'''
if self.excuteFlag1 == True:
self.excuteFlag1 = False
os.system("python2 myoMain.py")
time.sleep(0.01)
def removeExitFile(self , fileName = "actionTempData.dat" ):
'''删除已经存在的文件'''
if os.path.exists(fileName) == True:
os.remove(fileName)
def setIndoorFly(self):
'''设置室内飞行的参数'''
self.bebop.set_max_tilt(5)
self.bebop.set_max_vertical_speed(1)
def getKeyValueMain(self):
'''获取按键值的线程函数'''
if self.excuteFlag2 == True:
self.excuteFlag2 = False
os.system("python2 quit.py" )
time.sleep(0.01)
#按键退出函数
def quitMain(self):
print("quit")
self.bebop.safe_land(10)
self.bebop.smart_sleep(5)
self.bebop.disconnect()
self.mThread.forcedStopThread()
def getTheActionMain(self):
'''得到动作类别线程函数'''
global quitFlag
while True:
self.actionType = getTheCurrentAction()
getTheKeyValue()
if quitFlag == True:
self.quitMain()
else:
if self.actionType == None:
self.tempCount += 1
else:
self.tempCount = 0
self.safeAction()
if self.executeCommondFlag == True:
self.bebopFly(self.actionType)
time.sleep(0.01)
def run(self):
'''运行主程序'''
try:
self.mThread = myThread()
self.mThread.addThread('setTheActionMain' , self.setTheActionMain , 0)
self.mThread.addThread('getTheActionMain' , self.getTheActionMain , 0)
self.mThread.addThread('getKeyValueMain' , self.getKeyValueMain , 0)
self.mThread.runThread()
except KeyboardInterrupt:
print("DONE")
self.bebop.disconnect()
self.mThread.forcedStopThread()
try:
s.bind((host, port))
except socket.error as e:
print(str(e))
s.listen(5)
print("Waiting for a connection")
# make my bebop object
bebop = Bebop()
# connect to the bebop
success = bebop.connect(5)
if (success):
bebop.smart_sleep(3)
bebop.ask_for_state_update()
flightProc = mp.Process(target=flight_plan, args=(keepGoing, ))
flightProc.start()
collisionProc = mp.Process(target=collision_avoidance,
args=(keepGoing, ))
collisionProc.start()
while (keepGoing.value == 1):
continue
bebop.disconnect()
//test for flight
from pyparrot.Bebop import Bebop
import math
bebop = Bebop()
print("connecting")
success = bebop.connect(10)
print(success)
print("sleeping")
bebop.smart_sleep(5)
bebop.ask_for_state_update()
bebop.safe_takeoff(5)
print("Flying direct: going forward (positive pitch)")
bebop.fly_direct(roll=0, pitch=50, yaw=0, vertical_movement=0, duration=1)
print("Flying direct: yaw")
bebop.fly_direct(roll=0, pitch=0, yaw=50, vertical_movement=0, duration=1)
print("Flying direct: going backwards (negative pitch)")
bebop.fly_direct(roll=0, pitch=-50, yaw=0, vertical_movement=0, duration=0.5)
print("Flying direct: roll")
bebop.fly_direct(roll=50, pitch=0, yaw=0, vertical_movement=0, duration=1)
print("Flying direct: going up")
class Drone:
def __init__(self):
self.drone = Bebop()
def take_off(self):
### Connect to Bebop drone and take off ###
success = self.drone.connect1(10)
print(success)
self.drone.safe_takeoff(2)
def step(self, roll, pitch, yaw, vertical_movement, duration):
### Moves the Bebop drone given input parameters ###
self.drone.fly_direct(self, roll, pitch, yaw, vertical_movement,
duration)
def square(self):
### Move the drone in a square pattern###
#move left and wait 1 second
self.drone.fly_direct(self,
roll=-15,
pitch=0,
yaw=0,
vertical_movement=0,
duration=1)
self.drone.smart_sleep(1)
#move forward and wait 1 second
self.drone.fly_direct(self,
roll=0,
pitch=15,
yaw=0,
vertical_movement=0,
duration=1)
self.drone.smart_sleep(1)
#move right and wait 1 second
self.drone.fly_direct(self,
roll=15,
pitch=0,
yaw=0,
vertical_movement=0,
duration=1)
self.drone.smart_sleep(1)
#move back and wait 1 second
self.drone.fly_direct(self,
roll=0,
pitch=-15,
yaw=0,
vertical_movement=0,
duration=1)
self.drone.smart_sleep(1)
def zigzag(self):
### Move the drone in a 3D zigzag pattern###
#move left-forward-up and wait 1 second
self.drone.fly_direct(self,
roll=-15,
pitch=15,
yaw=0,
vertical_movement=15,
duration=1)
self.drone.smart_sleep(1)
#move right-forward-down and wait 1 second
self.drone.fly_direct(self,
roll=15,
pitch=15,
yaw=0,
vertical_movement=-15,
duration=1)
self.drone.smart_sleep(1)
#move left and wait 1 second
self.drone.fly_direct(self,
roll=-15,
pitch=0,
yaw=0,
vertical_movement=0,
duration=1)
self.drone.smart_sleep(1)
#move right-back-up and wait 1 second
self.drone.fly_direct(self,
roll=15,
pitch=-15,
yaw=0,
vertical_movement=15,
duration=1)
self.drone.smart_sleep(1)
#move left-back-down and wait 1 second
self.drone.fly_direct(self,
roll=-15,
pitch=-15,
yaw=0,
vertical_movement=-15,
duration=1)
self.drone.smart_sleep(1)
def disconnect(self):
### Disconect Bebop drone ###
self.drone.disconnect()
def land(self):
### Disconnect Bebop drone and land ###
success = self.drone.connect1(10)
print(success)
self.drone.ask_for_state_update()
self.drone.safe_land(5)
self.drone.disconnect()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
sess = tf.Session(graph=detection_graph)
# Loading label map
# Label maps map indices to category names, so that when our convolution network predicts `5`, we know that this corresponds to `airplane`. Here we use internal utility functions, but anything that returns a dictionary mapping integers to appropriate string labels would be fine
label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
categories = label_map_util.convert_label_map_to_categories(
label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
category_index = label_map_util.create_category_index(categories)
drone = Bebop()
success = drone.connect(5)
#drone.set_picture_format('jpeg')
is_bebop = True
if (success):
# get the state information
print("sleeping")
drone.smart_sleep(1)
drone.ask_for_state_update()
drone.smart_sleep(1)
status = input("Input 't' if you want to TAKE OFF or not : ")
bebopVision = DroneVisionGUI(drone, is_bebop=True, buffer_size=200,user_code_to_run=tracking_target,
user_args=(drone, status, q))
Kim = Kim(bebopVision)
bebopVision.set_user_callback_function(Kim.detect_target, user_callback_args=(category_index,detection_graph,sess))
bebopVision.open_video()
# make my bebop object
bebop = Bebop()
# connect to the bebop
success = bebop.connect(5)
if (success):
bebopVision = DroneVision(bebop, Model.BEBOP, buffer_size = 1)
userVision = UserVision(bebopVision)
bebopVision.set_user_callback_function(userVision.streamVideo, user_callback_args=None)
success = bebopVision.open_video()
if (success):
print("Vision successfully started!")
#removed the user call to this function (it now happens in open_video())
#bebopVision.start_video_buffering()
# skipping actually flying for safety purposes indoors - if you want
# different pictures, move the bebop around by hand
print("Fly me around by hand!")
bebop.smart_sleep(5)
bebop.smart_sleep(120)
print("Finishing demo and stopping vision")
bebopVision.close_video()
uservision.vw.release()
# disconnect nicely so we don't need a reboot
bebop.disconnect()
else:
print("Error connecting to bebop. Retry")
class PyParrot(gui.MyFrame1):
def __init__(self, parent):
gui.MyFrame1.__init__(self, parent)
self.statusBar.SetStatusWidths([100, -1])
self.statusBar.SetStatusText('Not Connected')
self.lc_commands.InsertColumn(0, 'command', width=300)
self.bebop = Bebop()
# load saved commands from file
self._loadJsonFile()
def OnClose( self, event ):
if wx.MessageBox("Commands are not yet saved. Do you want to save now?", "Save Changes", wx.ICON_QUESTION | wx.YES_NO) == wx.YES:
# Retrive commands from lc_commands
cmdList = []
for i in range(self.lc_commands.GetItemCount()):
cmdList.append(self.lc_commands.GetItemText(i))
self._saveJsonFile(cmdList)
self.OnDisconnect(None)
event.Skip() # calls the parent close method
def OnConnect( self, event ):
isConnected = self.bebop.connect(10)
statusText = 'Connected'
if not isConnected:
statusText = 'Not ' + statusText
self.statusBar.SetStatusText(statusText)
def OnDisconnect( self, event ):
self.bebop.disconnect()
self.statusBar.SetStatusText('Disconnected')
self.statusBar.SetStatusText(f'Battery: {self.bebop.sensors.battery}%', 1)
def OnTakeOff( self, event ):
self.bebop.safe_takeoff(10)
# By default, setting the status text only sets the first
# one. So we must specify the second status text (index 1
# , instead of index 0)
self.statusBar.SetStatusText('Taking off', 1)
def OnLand( self, event ):
self.bebop.safe_land(10)
self.statusBar.SetStatusText('Landing', 1)
def OnAddTakeOff( self, event ):
self._addCommand(f'{CmdType.TakeOff.value},10')
def OnAddLand( self, event ):
self._addCommand(f'{CmdType.Land.value},10')
def OnAddRelative( self, event ):
x = int(self.fld_x.GetValue())
y = int(self.fld_y.GetValue())
z = int(self.fld_z.GetValue())
rads = int(self.fld_radians.GetValue())
self._addCommand(f'{CmdType.Relative.value},{x},{y},{z},{rads}')
def OnAddDirect( self, event ):
roll = int(self.fld_roll.GetValue())
pitch = int(self.fld_pitch.GetValue())
yaw = int(self.fld_yaw.GetValue())
vertical = int(self.fld_vertical.GetValue())
duration = int(self.fld_duration.GetValue())
self._addCommand(f'{CmdType.Direct.value},{roll},{pitch},{yaw},{vertical},{duration}')
def OnAddSleep( self, event ):
sleep = int(self.fld_sleep.GetValue())
self._addCommand(f'{CmdType.Sleep.value},{sleep}')
def OnAddFlip( self, event ):
dir = str(self.fld_direction.GetValue())
self._addCommand(f'{CmdType.Flip.value},{dir}')
def OnAddFlyGrid(self, event):
print("Make sure you take off first!")
heightGain = int(self.fld_gridHeight.GetValue())
lengthForward = int(self.fld_gridLength.GetValue())
width = int(self.fld_gridWidth.GetValue())
biLines = int(self.fld_gridLines.GetValue())
widthSection = width/(biLines+1)
# Rise
self._addCommand(f'{CmdType.Relative.value},0,0,{heightGain},0')
# Fly forward and turn right
self._addCommand(f'{CmdType.Relative.value},{lengthForward},0,0,90')
# Flip
self._addCommand(f'{"flip"},{"up"}')
# Fly right and turn right
self._addCommand(f'{CmdType.Relative.value},{widthSection},0,0,90')
# Flip
self._addCommand(f'{"flip"},{"up"}')
# Fly back and turn left
self._addCommand(f'{CmdType.Relative.value},{lengthForward},0,0,-90')
# Flip
self._addCommand(f'{"flip"},{"up"}')
while (biLines >= 2):
biLines -= 2
# Fly right and turn left
self._addCommand(f'{CmdType.Relative.value},{widthSection},0,0,-90')
# Flip
self._addCommand(f'{"flip"},{"up"}')
# Fly forward and turn right
self._addCommand(f'{CmdType.Relative.value},{lengthForward},0,0,90')
# Flip
self._addCommand(f'{"flip"},{"up"}')
# Fly right and turn right
self._addCommand(f'{CmdType.Relative.value},{widthSection},0,0,90')
# Flip
self._addCommand(f'{"flip"},{"up"}')
# Fly back and turn left
self._addCommand(f'{CmdType.Relative.value},{lengthForward},0,0,-90')
# Flip
self._addCommand(f'{"flip"},{"up"}')
if (biLines == 1):
biLines -= 1
# Fly right and turn left
self._addCommand(f'{CmdType.Relative.value},{widthSection},0,0,-90')
# Flip
self._addCommand(f'{"flip"},{"up"}')
# Fly forward
self._addCommand(f'{CmdType.Relative.value},{lengthForward},0,0,0')
# Flip
self._addCommand(f'{"flip"},{"up"}')
# Fly back left to home
self._addCommand(f'{CmdType.Relative.value},{-lengthForward},{-width},0,0')
# Flip
self._addCommand(f'{"flip"},{"up"}')
# Descend
self._addCommand(f'{CmdType.Relative.value},0,0,{-heightGain},0')
else:
# Fly left and turn left
self._addCommand(f'{CmdType.Relative.value},{-width},0,0,-90')
# Flip
self._addCommand(f'{"flip"},{"up"}')
# Descend
self._addCommand(f'{CmdType.Relative.value},0,0,{-heightGain},0')
print("Make sure you land!")
def OnRemove( self, event ):
self.lc_commands.DeleteItem(self.lc_commands.GetFocusedItem())
def OnUp( self, event ):
"""Swap the selected item with the one above it"""
index = self.lc_commands.GetFocusedItem()
if index >= 1:
selItemStr = self.lc_commands.GetItemText(index)
aboveItemStr = self.lc_commands.GetItemText(index-1)
self.lc_commands.SetItemText(index, aboveItemStr)
self.lc_commands.SetItemText(index-1, selItemStr)
self.lc_commands.Focus(index-1)
def OnDown( self, event ):
"""Swap the selected item with the one below it"""
index = self.lc_commands.GetFocusedItem()
if index < self.lc_commands.GetItemCount() - 1:
selItemStr = self.lc_commands.GetItemText(index)
belowItemStr = self.lc_commands.GetItemText(index+1)
self.lc_commands.SetItemText(index, belowItemStr)
self.lc_commands.SetItemText(index+1, selItemStr)
self.lc_commands.Focus(index+1)
def OnClear( self, event ):
self.lc_commands.DeleteAllItems()
def OnRunFromSelection( self, event ):
index = self.lc_commands.GetFocusedItem()
while index > 0:
self.lc_commands.DeleteItem(index - 1)
index = self.lc_commands.GetFocusedItem()
self.OnRunCommands(event)
def OnRunCommands( self, event ):
"""Go through each item in lc_commands and convert the string to
a list. Then use the first item in the list to determine the
command type, and the rest of the items are the params"""
# Retrive commands from lc_commands
cmdList = []
for i in range(self.lc_commands.GetItemCount()):
cmdList.append(self.lc_commands.GetItemText(i))
self._saveJsonFile(cmdList)
# Abort running attempt if not connected
if not self.bebop.drone_connection.is_connected:
print("No Connection. Aborting process.")
return
# === Run Commands ===
for i in range(self.lc_commands.GetItemCount()):
args = self.lc_commands.GetItemText(i).split(',')
self.statusBar.SetStatusText(f'Executing command: {args}', 1)
try:
if (args[0] == CmdType.Sleep.value):
self.bebop.smart_sleep(int(args[1]))
elif args[0] == CmdType.TakeOff.value:
self.bebop.safe_takeoff(int(args[1]))
elif args[0] == CmdType.Land.value:
self.bebop.safe_land(int(args[1]))
elif args[0] == CmdType.Direct.value:
self.bebop.fly_direct(int(args[1]), int(args[2]), int(args[3]), int(args[4]), int(args[5]))
elif args[0] == CmdType.Relative.value:
self.bebop.move_relative(int(args[1]), int(args[2]), int(args[3]), math.radians(int(args[4])))
elif args[0] == CmdType.Flip.value:
self.bebop.flip(str(args[1]))
except Exception as e:
print("Error occurred: ")
print(e)
continue
def _loadJsonFile(self):
# Open up JSON file with last run commands
filePath = os.getcwd() + os.sep + "cmd_data.json"
if os.path.isfile(filePath):
f = open(filePath,"r")
s = f.read()
commands = json.loads(s)
# Input commands into GUI interface
for c in commands:
self._addCommand(c)
def _saveJsonFile(self, cmdList):
# Place all commands into JSON file and write them to the disk
jsonStr = json.dumps(cmdList)
filePath = os.getcwd() + os.sep + "cmd_data.json"
with open(filePath,"w") as f:
f.write(jsonStr)
def _addCommand(self, cmd: str):
self.lc_commands.InsertItem(self.lc_commands.GetItemCount(), cmd)
self.statusBar.SetStatusText(f'Added command: {cmd}', 1)
from pyparrot.Bebop import Bebop
import math
bebop = Bebop()
print("connecting")
success = bebop.connect(20)
print(success)
print("sleeping")
bebop.smart_sleep(.5)
bebop.ask_for_state_update()
bebop.safe_takeoff(5)
bebop.fly_direct(roll=0, pitch=0, yaw=0, vertical_movement=-20,
duration=1) # lowwers drown
bebop.smart_sleep(1)
## first movment do not change
bebop.fly_direct(roll=0, pitch=50, yaw=0, vertical_movement=0,
duration=4.7) # forward
bebop.fly_direct(roll=0, pitch=-100, yaw=0, vertical_movement=0, duration=1.2)
bebop.smart_sleep(2)
#second movement
bebop.fly_direct(roll=50, pitch=5, yaw=0, vertical_movement=0,
duration=1.7) # right
bebop.fly_direct(roll=-50, pitch=0, yaw=0, vertical_movement=0, duration=.5)
bebop.smart_sleep(2)
success = bebop.connect(5)
if (success):
# start up the video
bebopVision = DroneVision(bebop, is_bebop=True)
userVision = UserVision(bebopVision)
bebopVision.set_user_callback_function(userVision.save_pictures,
user_callback_args=None)
success = bebopVision.open_video()
if (success):
print("Vision successfully started!")
print("sleeping")
bebop.smart_sleep(2)
bebop.ask_for_state_update()
bebop.safe_takeoff(10)
bebop.smart_sleep(2)
print("Moving the camera using velocity")
# bebop.pan_tilt_camera_velocity(pan_velocity=0, tilt_velocity=-6, duration=4)
total = 2 #Number of times grid searching is done
globalCounter = 0 #Temporary counter
amount = 8 #Number of seconds we fly total per direction
repetitions = 4
while (globalCounter < total):
checkWait()
num_episode = 22
batch_size = 3
learning_rate = 0.01
gamma = 1
optimizer = torch.optim.RMSprop(policy_net.parameters(), lr=learning_rate)
# Batch History
state_pool = []
action_pool = []
reward_pool = []
best_reward=0
steps_grad = 0
dx = [0]
try:
pitch = 80
if (success):
bebop.smart_sleep(2)
bebop.ask_for_state_update()
print('safe_takeoff')
bebop.safe_takeoff(10)
bebop.set_hull_protection(1)
bebop.set_max_distance(10)
bebop.set_max_altitude(5)
print('going up')
bebop.fly_direct(roll=0, pitch=0, yaw=0, vertical_movement=10, duration=3)
bebop.fly_direct(roll=0, pitch=0, yaw=0, vertical_movement=10, duration=3)
print('add pendulum')
bebop.smart_sleep(10)
for e in range(num_episode):
print('Episode : ', e)
count =0
angle = getAngle()
if (success):
# start up the video
bebopVision = DroneVision(bebop, is_bebop=True)
userVision = UserVision(bebopVision)
bebopVision.set_user_callback_function(userVision.save_pictures,
user_callback_args=None)
success = bebopVision.open_video()
if (success):
print("Vision successfully started!")
#removed the user call to this function (it now happens in open_video())
#bebopVision.start_video_buffering()
pyparrot.VisionServer.IMAGE_PATH = '/Users/Artemiss/.pyenv/versions/3.7.3/lib/python3.7/site-packages/pyparrot/images/image_%03d.png'
pyparrot.VisionServer.main()
# skipping actually flying for safety purposes indoors - if you want
# different pictures, move the bebop around by hand
print("Fly me around by hand!")
bebop.smart_sleep(15)
print("Moving the camera using velocity")
# bebop.pan_tilt_camera_velocity(pan_velocity=0, tilt_velocity=-2, duration=4)
# bebop.smart_sleep(25)
print("Finishing demo and stopping vision")
bebopVision.close_video()
# disconnect nicely so we don't need a reboot
bebop.disconnect()
else:
print("Error connecting to bebop. Retry")
# connect to the bebop
success = bebop.connect(5)
if (success):
# start up the video
bebopVision = DroneVision(bebop, is_bebop=True)
userVision = UserVision(bebopVision)
bebopVision.set_user_callback_function(userVision.save_pictures, user_callback_args=None)
success = bebopVision.open_video()
if (success):
print("Vision successfully started!")
print("sleeping")
bebop.smart_sleep(2)
bebop.ask_for_state_update()
bebop.safe_takeoff(10)
bebop.smart_sleep(2)
print("Moving the camera using velocity")
bebop.pan_tilt_camera_velocity(pan_velocity=0, tilt_velocity=-2, duration=4)
bebop.smart_sleep(120)
bebop.safe_land(10)
print("Finishing demo and stopping vision")
bebopVision.close_video()
# disconnect nicely so we don't need a reboot
bebop.disconnect()
