示例#1
0
    def init_mavlink(self, master_dev, gcs_dev, extra, baudrate):

        # master
        master = mavutil.mavserial(master_dev,
                                   baud=baudrate,
                                   autoreconnect=True)
        print 'master connected on device: ', master_dev

        # gcs
        if gcs_dev is not None:
            gcs = mavutil.mavudp(gcs_dev, input=False)
            print 'gcs connected on device: ', gcs_dev
        self.extra_out = None
        if extra:
            try:
                extra = int(extra)
            except:
                raise TypeError("extraOut must be int or NONE")
            extra_out = mavutil.mavudp(gcs_dev,
                                       input=False,
                                       source_system=extra)
            print 'Unmodified sensor output connected on device: ',\
                   gcs_dev, ' with vehicle ID ', extra
            self.extra_out = extra_out

        # class data
        self.master = master
        self.gcs = gcs
示例#2
0
    def init_mavlink(self, master_dev, gcs_dev, extra, baudrate):

        # master
        master = mavutil.mavserial(master_dev, baud=baudrate, autoreconnect=True)
        print 'master connected on device: ', master_dev

        # gcs
        if gcs_dev is not None:
            gcs = mavutil.mavudp(gcs_dev, input=False)
            print 'gcs connected on device: ', gcs_dev
        self.extra_out = None
        if extra:
            try:
                extra = int(extra)
            except:
                raise TypeError("extraOut must be int or NONE")
            extra_out = mavutil.mavudp(gcs_dev, input=False,
                                       source_system=extra)
            print 'Unmodified sensor output connected on device: ',\
                   gcs_dev, ' with vehicle ID ', extra
            self.extra_out = extra_out


        # class data
        self.master = master
        self.gcs = gcs
示例#3
0
文件: ap_state.py 项目: cglusky/junk
 def __init__(self):
     self.control_connection_in = mavutil.mavudp("127.0.0.1:14769")
     self.control_link_in = mavutil.mavlink.MAVLink(self.control_connection_in)
     self.control_connection_out = mavutil.mavudp("127.0.0.1:14779", input=False)
     self.control_link_out = mavutil.mavlink.MAVLink(self.control_connection_out)
     self.control_link_out.srcSystem = 122
     self.control_link_out.srcComponent = 3
     self.current_state = State(time_stamp=int((time.time()%1000)*100), data = {})
     self.state_history = []
     self.state_history_max_length = 1000 #samples
     
     self.alive = True
示例#4
0
    def __init__(self, queue):
        self.alive = True
        self.control_connection_in = mavutil.mavudp("127.0.0.1:14668")
        self.control_link_in = mavutil.mavlink.MAVLink(self.control_connection_in)
        self.control_connection_out = mavutil.mavudp("127.0.0.1:14678", input=False)
        self.control_link_out = mavutil.mavlink.MAVLink(self.control_connection_out)
        self.control_link_out.srcSystem = 122
        self.control_link_out.srcComponent = 254
	
	self.block_timeout = 10. #seconds (-1 = inf)
	self.idle_timeout = 2.
        self.block_time = time.time()
	self.recv_count = 0
	self.send_count = 0
	self.send_timer = time.time()
	self.recv_timer = time.time()
	self.notify_flag =False
	self.idle=False

        self.media_queue = queue
        debug = True
        bandwidth = 320000
        ordered = False
        packet_loss = False
        backlog=100
        chunk_size=1000 #max = 65535
        dest_ip = '10.7.7.1'
        listen_ip = '10.7.7.2'
        # setup a send/recv pair
        self.block_connetion = block_sender.BlockSender(dest_ip = dest_ip,
                                                        listen_ip= listen_ip,
                                                        dest_port = 6000,
                                                        port =7000,
                                                        debug=debug, bandwidth=bandwidth,
                                                        ordered=ordered, chunk_size=chunk_size,
                                                        backlog=backlog)

        if packet_loss:
            self.block_connetion.set_packet_loss(packet_loss)
            
        self.target_block_numbers = (1,1, 1)
        self.raw_block_list  = []
        self.processed_block_list = []
        
        
        self.high_block_priority = 3
        self.first_block_priority = 2
        self.normal_block_priority = 1
        self.low_block_priority = 0
示例#5
0
    def _udp_thread(self):
        """
        I. Check queue from PX4 for messages
        II. Check messages from GCS via UDP and pass onto PX4
        """
        while not self.running:
            time.sleep(0.01)

        socket = mavutil.mavudp(device=self.udp_str, input=False)

        logging.info('Started UDP message handling loop')
        while self.running:
            # I. Check queue from PX4 for messages
            while self.queue_out:
                msg_bytes = self.process_mav_message()
                socket.write(msg_bytes)

            # II. Check messages from GCS via UDP and pass onto PX4
            msg = socket.recv_msg()
            while msg:
                self.px4.write(msg.get_msgbuf())
                msg = socket.recv_msg()

            time.sleep(0.001)

        # Device closed
        socket.close()
示例#6
0
    def __init__(self, queue_in, queue_out):
        self.storage = 1# 1 = keep, 0 = don't keep
        self.alive = True
        self.control_connection_in = mavutil.mavudp("127.0.0.1:14667")
        self.control_link_in = mavutil.mavlink.MAVLink(self.control_connection_in)
        self.control_connection_out = mavutil.mavudp("127.0.0.1:14677", input=False)
        self.control_link_out = mavutil.mavlink.MAVLink(self.control_connection_out)
        self.control_link_out.srcSystem = 122
        self.control_link_out.srcComponent = 200

        self.new_media = False
        self.media_queue_in = queue_in
        self.media_queue_out = queue_out
        self.media_buffer = []
        self.media_buffer_max = 5
        self.send_media = True #if true we will try to send media
    def __init__(self, target=[0, 0, 5]):
        self.iris_index = 2
        self.position_x = 0
        self.position_y = 0
        self.position_z = 0
        self.orientation_x = 0
        self.orientation_y = 0
        self.orientation_z = 0
        self.orientation_w = 1
        self.linear_x = 0
        self.linear_y = 0
        self.linear_z = 0
        self.angular_x = 0
        self.angular_y = 0
        self.angular_z = 0
        self.random_seed = None
        self.target = target

        print "Connecting..."
        self.udp = mavutil.mavudp('127.0.0.1:14560', source_system=0)  #gazebo
        rospy.init_node('listener', anonymous=True)
        rate = rospy.Rate(500)  # 10hz
        # env.seed(0)
        rospy.Subscriber("/gazebo/model_states", ModelStates,
                         self.model_states_callback)
示例#8
0
 def create_connection(self):
     state = self.state
     
     ## camera
     connection = mavutil.mavudp("127.0.0.1:14676", input= True)
     link = mavutil.mavlink.MAVLink(connection)
     new_connection = Connection(connection, link, system_id = 122, component_id = 101, input=True)
     self.add_connection_to_table(new_connection)
     
     connection = mavutil.mavudp("127.0.0.1:14666", input= False)
     link = mavutil.mavlink.MAVLink(connection)
     new_connection = Connection(connection, link, system_id = 122, component_id = 100, output=True)
     self.add_connection_to_table(new_connection)
     
     ## media manager
     connection = mavutil.mavudp("127.0.0.1:14677", input= True)
     link = mavutil.mavlink.MAVLink(connection)
     new_connection = Connection(connection, link, system_id = 122, component_id = 201, input=True)
     self.add_connection_to_table(new_connection)
     
     connection = mavutil.mavudp("127.0.0.1:14667", input= False)
     link = mavutil.mavlink.MAVLink(connection)
     new_connection = Connection(connection, link, system_id = 122, component_id = 200, output=True)
     self.add_connection_to_table(new_connection)
     
     ## block sender
     connection = mavutil.mavudp("127.0.0.1:14678", input= True)
     link = mavutil.mavlink.MAVLink(connection)
     new_connection = Connection(connection, link, system_id = 122, component_id = 253, input=True)
     self.add_connection_to_table(new_connection)
     
     connection = mavutil.mavudp("127.0.0.1:14668", input= False)
     link = mavutil.mavlink.MAVLink(connection)
     new_connection = Connection(connection, link, system_id = 122, component_id = 254, output=True)
     self.add_connection_to_table(new_connection)
     
     ## mount (gimbal)
     
     
     ## ap bi-directional
     connection = mavutil.mavserial("/dev/serial/by-id/usb-FTDI_FT232R_USB_UART_A4006JAo-if00-port0",baud=57600)
     link = mavutil.mavlink.MAVLink(connection)
     new_connection = Connection(connection, link, system_id = 122, component_id = 1, input=True, output=True)
     self.add_connection_to_table(new_connection)
     
     
     ## ap_state
     connection = mavutil.mavudp("127.0.0.1:14779", input= True)
     link = mavutil.mavlink.MAVLink(connection)
     new_connection = Connection(connection, link, system_id = 122, component_id = 2, input=True)
     self.add_connection_to_table(new_connection)
     
     connection = mavutil.mavudp("127.0.0.1:14769", input= False)
     link = mavutil.mavlink.MAVLink(connection)
     new_connection = Connection(connection, link, system_id = 122, component_id = 3, output=True)
     self.add_connection_to_table(new_connection)
示例#9
0
文件: main.py 项目: apex256/sitl
def workerThread(threadname):
    global startTime, x_vals, y_vals, flag
    mav = mavutil.mavudp("0.0.0.0:14550", input=True)
    while flag:
        status = mav.recv_msg()
        if (status != None and status.get_type() == "GLOBAL_POSITION_INT"):
            y_vals.append(status.alt)
            x_vals.append(timeit.default_timer() - startTime)
示例#10
0
    def __init__(self, filename):
        self.root = Tkinter.Tk()

        self.filesize = os.path.getsize(filename)
        self.filepos = 0.0

        self.mlog = mavutil.mavlink_connection(filename, planner_format=args.planner,
                                               robust_parsing=True)
        self.mout = []
        for m in args.out:
            self.mout.append(mavutil.mavlink_connection(m, input=False, baud=args.baudrate))

        self.fgout = []
        for f in args.fgout:
            self.fgout.append(mavutil.mavudp(f, input=False))

        self.fdm = fgFDM.fgFDM()

        self.msg = self.mlog.recv_match(condition=args.condition)
        if self.msg is None:
            sys.exit(1)
        self.last_timestamp = getattr(self.msg, '_timestamp')

        self.paused = False

        self.topframe = Tkinter.Frame(self.root)
        self.topframe.pack(side=Tkinter.TOP)

        self.frame = Tkinter.Frame(self.root)
        self.frame.pack(side=Tkinter.LEFT)

        self.slider = Tkinter.Scale(self.topframe, from_=0, to=1.0, resolution=0.01,
                                    orient=Tkinter.HORIZONTAL, command=self.slew)
        self.slider.pack(side=Tkinter.LEFT)

        self.clock = Tkinter.Label(self.topframe,text="")
        self.clock.pack(side=Tkinter.RIGHT)

        self.playback = Tkinter.Spinbox(self.topframe, from_=0, to=20, increment=0.1, width=3)
        self.playback.pack(side=Tkinter.BOTTOM)
        self.playback.delete(0, "end")
        self.playback.insert(0, 1)

        self.buttons = {}
        self.button('quit', 'gtk-quit.gif', self.frame.quit)
        self.button('pause', 'media-playback-pause.gif', self.pause)
        self.button('rewind', 'media-seek-backward.gif', self.rewind)
        self.button('forward', 'media-seek-forward.gif', self.forward)
        self.button('status', 'Status', self.status)
        self.flightmode = Tkinter.Label(self.frame,text="")
        self.flightmode.pack(side=Tkinter.RIGHT)

        self.next_message()
        self.root.mainloop()
示例#11
0
    def __init__(self, filename):
        self.root = Tkinter.Tk()

        self.filesize = os.path.getsize(filename)
        self.filepos = 0.0

        self.mlog = mavutil.mavlink_connection(filename, planner_format=opts.planner,
                                               robust_parsing=True)
        self.mout = []
        for m in opts.out:
            self.mout.append(mavutil.mavlink_connection(m, input=False, baud=opts.baudrate))

        self.fgout = []
        for f in opts.fgout:
            self.fgout.append(mavutil.mavudp(f, input=False))
    
        self.fdm = fgFDM.fgFDM()

        self.msg = self.mlog.recv_match(condition=opts.condition)
        if self.msg is None:
            sys.exit(1)
        self.last_timestamp = getattr(self.msg, '_timestamp')

        self.paused = False

        self.topframe = Tkinter.Frame(self.root)
        self.topframe.pack(side=Tkinter.TOP)

        self.frame = Tkinter.Frame(self.root)
        self.frame.pack(side=Tkinter.LEFT)

        self.slider = Tkinter.Scale(self.topframe, from_=0, to=1.0, resolution=0.01,
                                    orient=Tkinter.HORIZONTAL, command=self.slew)
        self.slider.pack(side=Tkinter.LEFT)

        self.clock = Tkinter.Label(self.topframe,text="")
        self.clock.pack(side=Tkinter.RIGHT)

        self.playback = Tkinter.Spinbox(self.topframe, from_=0, to=20, increment=0.1, width=3)
        self.playback.pack(side=Tkinter.BOTTOM)
        self.playback.delete(0, "end")
        self.playback.insert(0, 1)

        self.buttons = {}
        self.button('quit', 'gtk-quit.gif', self.frame.quit)
        self.button('pause', 'media-playback-pause.gif', self.pause)
        self.button('rewind', 'media-seek-backward.gif', self.rewind)
        self.button('forward', 'media-seek-forward.gif', self.forward)
        self.button('status', 'Status', self.status)
        self.flightmode = Tkinter.Label(self.frame,text="")
        self.flightmode.pack(side=Tkinter.RIGHT)

        self.next_message()
        self.root.mainloop()
示例#12
0
    def __init__(self, queue):
        self.capture_mode = 1  # 0 = wait for cmd and action, 1  = auto loop interval

        self.control_connection_in = mavutil.mavudp("127.0.0.1:14666")
        self.control_link_in = mavutil.mavlink.MAVLink(
            self.control_connection_in)
        self.control_connection_out = mavutil.mavudp("127.0.0.1:14676",
                                                     input=False)
        self.control_link_out = mavutil.mavlink.MAVLink(
            self.control_connection_out)
        self.control_link_out.srcSystem = 122
        self.control_link_out.srcComponent = 100

        self.table_ports = [self.control_connection_in.port]

        self.capture_interval = 2  #seconds. used for auto capture
        self.alive = True
        self.current_meta_image_index = None
        self.target_system = 1
        self.target_component = 1
        self.camera_type = "vfl"
        self.media_queue = queue
        self.image_index = 0
        self.capture_time = time.time()
        self.media_buffer = []
        self.media_buffer_max_count = 5  #media objects
        self.media_buffer_max_age = 5  #seconds
        self.request_ap_meta = True
        self.request_mount_meta = False  #currently there is no mount...
        self.capture_retry_max = -1  #-1 = inf, 0 = no retry, 1, 2, 3, etc...
        self.capture_retry_count = 0
        self.prev_img = Media()

        if self.camera_type == 'canon':
            self.camera = gphoto_image_capture.Camera()
        if self.camera_type == 'fake':
            self.camera = fake_image_capture.Camera()
        if self.camera_type == 'sony':
            self.camera = sony_image_capture.Camera()
        if self.camera_type == 'vfl':
            self.camera = vfl_image_capture.Camera()
示例#13
0
    def test_dump_length(self):
        mavutil.mavlink.WIRE_PROTOCOL_VERSION = 2
        mav = mavutil.mavudp(":12345")

        ts = [((1, 1), 14), ((1, 0), 13), ((0, 0), 13)]
        for t in ts:
            ((sysid, compid), result) = t
            m = mavutil.mavlink.MAVLink_param_request_list_message(
                sysid, compid)
            packed = m.pack(mav.mav)
            print("(%u/%u) should be %u" % (sysid, compid, result))
            self.assertEqual(len(packed), result)
示例#14
0
文件: runhil.py 项目: 9DSmart/HIL
    def init_mavlink(self, master_dev, gcs_dev, baudrate):

        # master
        master = mavutil.mavserial(master_dev, baud=baudrate, autoreconnect=True)
        print 'master connected on device: ', master_dev

        # gcs
        if gcs_dev is not None:
            gcs = mavutil.mavudp(gcs_dev, input=False)
            print 'gcs connected on device: ', gcs_dev

        # class data
        self.master = master
        self.gcs = gcs
示例#15
0
文件: runhil.py 项目: spurmoon/HIL
    def init_mavlink(self, master_dev, gcs_dev, baudrate):

        # master
        master = mavutil.mavserial(master_dev,
                                   baud=baudrate,
                                   autoreconnect=True)
        print 'master connected on device: ', master_dev

        # gcs
        if gcs_dev is not None:
            gcs = mavutil.mavudp(gcs_dev, input=False)
            print 'gcs connected on device: ', gcs_dev

        # class data
        self.master = master
        self.gcs = gcs
示例#16
0
    def __init__(self, ip, port):
        self.util = Utils()

        self.target_ip   = ip
        self.target_port = port

        self.new_packet = False
        self.current_packet = ""

        self.util.log("Starting mavudp session on - "+str(self.target_ip)+":"+str(self.target_port))
        self.mav = mavutil.mavudp(str(self.target_ip)+":"+str(self.target_port), input=True)
        
        self.MavBuffer = Queue()

        self.util.succLog("Starting Mavlink process")
        # thread.start_new_thread(self.startUDPStream, ())
        self.procMav = Process(target=self.startUDPStream, args=())
        self.procMav.start()
示例#17
0
    def __init__(self, filename):
        self.mlog = mavutil.mavlink_connection(filename)
        self.fgout = []
        for f in args.fgout:
            self.fgout.append(mavutil.mavudp(f, input=False))

        self.fdm = fgFDM.fgFDM()

        self.chute_released = False

        self.msg = self.next_msg()
        if self.msg is None:
            sys.exit(1)
        self.last_timestamp = self.msg.TimeUS*1.0e-6

        while True:
            self.next_message()
            if self.msg is None:
                break
示例#18
0
    def __init__(self, name, ip, port, remote_device):
        """
        Initializer

        :param name: Name for this object
        :param ip: IP address for MAVLink UDP connection with GCS
        :param port: Port unique to this vehicle for MAVLink UDP connection with GCS
        :param remote_device: RemoteXBeeDevice object associated with this UAVs XBee radio
        """
        self.name = name
        self.ip = ip
        self.port = port
        self.queue_in = MAVQueue()
        self.queue_out = MAVQueue()
        self.socket = mavutil.mavudp(device=f'{ip}:{port}', input=False)
        self.parser = mavlink.MAVLink(Fifo())
        self.device = remote_device
        self.connected = True
        logging.info(f'Assigned {name} link to UDP {(ip, port)}')
    def __init__(self, filename):
        self.mlog = mavutil.mavlink_connection(filename)
        self.fgout = []
        for f in args.fgout:
            self.fgout.append(mavutil.mavudp(f, input=False))

        self.fdm = fgFDM.fgFDM()

        self.chute_released = False

        self.msg = self.next_msg()
        if self.msg is None:
            sys.exit(1)
        self.last_timestamp = self.msg.TimeUS * 1.0e-6

        while True:
            self.next_message()
            if self.msg is None:
                break
示例#20
0
    def run(self):
        # send something to simulator to get it running
        self.sitl = mavutil.mavudp(self.sitl_address, input=False)
        self.sitl.write("hello")

        #setup output to flightgear

        if self.fg_address is not None:
            fg_address = (self.fg_address.split(':')[0], int(self.fg_address.split(':')[1]))
            self.fg_out = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            self.fg_out.connect(fg_address)

        self.init_JSBSim()
        util.pexpect_drain(self.jsb_console)
        self.jsb_console.send('resume\n')
        self.jsb_set('simulation/reset',1)
        self.update()
        self.jsb.expect("\(Trim\) executed")
        
        while self.update(): pass
示例#21
0
文件: mav.py 项目: ctphrs/MISCONSYS
    def __init__(self, ip, port):
        self.util = Utils()

        self.target_ip = ip
        self.target_port = port

        self.new_packet = False
        self.current_packet = ""

        self.util.log("Starting mavudp session on - " + str(self.target_ip) +
                      ":" + str(self.target_port))
        self.mav = mavutil.mavudp(str(self.target_ip) + ":" +
                                  str(self.target_port),
                                  input=True)

        self.MavBuffer = Queue()

        self.util.succLog("Starting Mavlink process")
        # thread.start_new_thread(self.startUDPStream, ())
        self.procMav = Process(target=self.startUDPStream, args=())
        self.procMav.start()
示例#22
0
    def run(self):
        # send something to simulator to get it running
        self.sitl = mavutil.mavudp(self.sitl_address, input=False)
        self.sitl.write("hello")

        #setup output to flightgear

        if self.fg_address is not None:
            fg_address = (self.fg_address.split(':')[0],
                          int(self.fg_address.split(':')[1]))
            self.fg_out = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            self.fg_out.connect(fg_address)

        self.init_JSBSim()
        util.pexpect_drain(self.jsb_console)
        self.jsb_console.send('resume\n')
        self.jsb_set('simulation/reset', 1)
        self.update()
        self.jsb.expect("\(Trim\) executed")

        while self.update():
            pass
示例#23
0
    if not opts.master and len(serial_list) == 1:
        print(("Connecting to %s" % serial_list[0]))
        mpstate.module('link').link_add(serial_list[0].device)
    elif not opts.master:
        wifi_device = '0.0.0.0:14550'
        mpstate.module('link').link_add(wifi_device)

    # open any mavlink output ports
    for port in opts.output:
        mpstate.mav_outputs.append(
            mavutil.mavlink_connection(port,
                                       baud=int(opts.baudrate),
                                       input=False))

    if opts.sitl:
        mpstate.sitl_output = mavutil.mavudp(opts.sitl, input=False)

    mpstate.settings.streamrate = opts.streamrate
    mpstate.settings.streamrate2 = opts.streamrate

    if opts.state_basedir is not None:
        mpstate.settings.state_basedir = opts.state_basedir

    msg_period = mavutil.periodic_event(1.0 / 15)
    heartbeat_period = mavutil.periodic_event(1)
    heartbeat_check_period = mavutil.periodic_event(0.33)

    mpstate.input_queue = queue.Queue()
    mpstate.input_count = 0
    mpstate.empty_input_count = 0
    if opts.setup:
示例#24
0
                                              udp.target_component, 150, 150,
                                              150, 150, 0, 0, 0, 0)
            data = udp.recv_msg()
            next_step()

        print 'stop'

        for i in range(100):
            udp.mav.rc_channels_override_send(udp.target_system,
                                              udp.target_component, 0, 0, 0, 0,
                                              0, 0, 0, 0)
            data = udp.recv_msg()
            next_step()

        print 'run'

        for i in range(100):
            udp.mav.rc_channels_override_send(udp.target_system,
                                              udp.target_component, 150, 150,
                                              150, 150, 0, 0, 0, 0)
            data = udp.recv_msg()
            next_step()

        print 'reset world'
        reset_env()


if __name__ == '__main__':
    print "Connecting"
    udp = mavutil.mavudp('127.0.0.1:14560', source_system=0)  #gazebo
    listener()
示例#25
0
        m.link_delayed = False
        m.last_heartbeat = 0
        m.last_message = 0
        m.highest_msec = 0
        mpstate.mav_master.append(m)
        mpstate.status.counters['MasterIn'].append(0)

    # log all packets from the master, for later replay
    open_logs()

    # open any mavlink UDP ports
    for p in opts.output:
        mpstate.mav_outputs.append(mavutil.mavlink_connection(p, baud=opts.baudrate, input=False))

    if opts.sitl:
        mpstate.sitl_output = mavutil.mavudp(opts.sitl, input=False)

    mpstate.settings.numcells = opts.num_cells
    mpstate.settings.streamrate = opts.streamrate
    mpstate.settings.streamrate2 = opts.streamrate

    msg_period = mavutil.periodic_event(1.0/15)
    heartbeat_period = mavutil.periodic_event(1)
    battery_period = mavutil.periodic_event(0.1)
    heartbeat_check_period = mavutil.periodic_event(0.33)

    mpstate.rl = rline.rline("MAV> ", mpstate)
    if opts.setup:
        mpstate.rl.set_prompt("")

    if 'HOME' in os.environ and not opts.setup:
def initMAVProxy():
    from optparse import OptionParser
    parser = OptionParser("mavproxy.py [options]")

    parser.add_option("--master", dest="master", action='append',
                      metavar="DEVICE[,BAUD]", help="MAVLink master port and optional baud rate",
                      default=[])
    parser.add_option("--out", dest="output", action='append',
                      metavar="DEVICE[,BAUD]", help="MAVLink output port and optional baud rate",
                      default=[])
    parser.add_option("--baudrate", dest="baudrate", type='int',
                      help="default serial baud rate", default=115200)
    parser.add_option("--sitl", dest="sitl",  default=None, help="SITL output port")
    parser.add_option("--streamrate",dest="streamrate", default=4, type='int',
                      help="MAVLink stream rate")
    parser.add_option("--source-system", dest='SOURCE_SYSTEM', type='int',
                      default=255, help='MAVLink source system for this GCS')
    parser.add_option("--target-system", dest='TARGET_SYSTEM', type='int',
                      default=1, help='MAVLink target master system')
    parser.add_option("--target-component", dest='TARGET_COMPONENT', type='int',
                      default=1, help='MAVLink target master component')
    parser.add_option("--logfile", dest="logfile", help="MAVLink master logfile",
                      default='mav.tlog')
    parser.add_option("-a", "--append-log", dest="append_log", help="Append to log files",
                      action='store_true', default=False)
    parser.add_option("--quadcopter", dest="quadcopter", help="use quadcopter controls",
                      action='store_true', default=False)
    parser.add_option("--setup", dest="setup", help="start in setup mode",
                      action='store_true', default=False)
    parser.add_option("--nodtr", dest="nodtr", help="disable DTR drop on close",
                      action='store_true', default=False)
    parser.add_option("--show-errors", dest="show_errors", help="show MAVLink error packets",
                      action='store_true', default=False)
    parser.add_option("--speech", dest="speech", help="use text to speach",
                      action='store_true', default=False)
    parser.add_option("--num-cells", dest="num_cells", help="number of LiPo battery cells",
                      type='int', default=0)
    parser.add_option("--aircraft", dest="aircraft", help="aircraft name", default=None)
    parser.add_option("--cmd", dest="cmd", help="initial commands", default=None)
    parser.add_option("--console", action='store_true', help="use GUI console")
    parser.add_option("--map", action='store_true', help="load map module")
    parser.add_option(
        '--load-module',
        action='append',
        default=[],
        help='Load the specified module. Can be used multiple times, or with a comma separated list')
    parser.add_option("--mav09", action='store_true', default=False, help="Use MAVLink protocol 0.9")
    parser.add_option("--auto-protocol", action='store_true', default=False, help="Auto detect MAVLink protocol version")
    parser.add_option("--nowait", action='store_true', default=False, help="don't wait for HEARTBEAT on startup")
    parser.add_option("--continue", dest='continue_mode', action='store_true', default=False, help="continue logs")
    parser.add_option("--dialect",  default="ardupilotmega", help="MAVLink dialect")
    parser.add_option("--rtscts",  action='store_true', help="enable hardware RTS/CTS flow control")

    (opts, args) = parser.parse_args()
    mavproxy.opts=opts

    if opts.mav09:
        os.environ['MAVLINK09'] = '1'
    from pymavlink import mavutil, mavparm
    mavutil.set_dialect(opts.dialect)

    # global mavproxy state
    mpstate = MPState()
    mavproxy.mpstate=mpstate
    mpstate.status.exit = False
    mpstate.command_map = command_map
    mpstate.continue_mode = opts.continue_mode

    if opts.speech:
        # start the speech-dispatcher early, so it doesn't inherit any ports from
        # modules/mavutil
        load_module('speech')

    if not opts.master:
        serial_list = mavutil.auto_detect_serial(preferred_list=['*FTDI*',"*Arduino_Mega_2560*", "*3D_Robotics*", "*USB_to_UART*"])
        if len(serial_list) == 1:
            opts.master = [serial_list[0].device]
        else:
            print('''
Please choose a MAVLink master with --master
For example:
    --master=com14
    --master=/dev/ttyUSB0
    --master=127.0.0.1:14550

Auto-detected serial ports are:
''')
            for port in serial_list:
                print("%s" % port)
            sys.exit(1)

    # container for status information
    mpstate.status.target_system = opts.TARGET_SYSTEM
    mpstate.status.target_component = opts.TARGET_COMPONENT

    mpstate.mav_master = []

    # open master link
    for mdev in opts.master:
        if ',' in mdev and not os.path.exists(mdev):
            port, baud = mdev.split(',')
        else:
            port, baud = mdev, opts.baudrate

        m = mavutil.mavlink_connection(port, autoreconnect=True, baud=int(baud))
        m.mav.set_callback(master_callback, m)
        if hasattr(m.mav, 'set_send_callback'):
            m.mav.set_send_callback(master_send_callback, m)
        if opts.rtscts:
            m.set_rtscts(True)
        m.linknum = len(mpstate.mav_master)
        m.linkerror = False
        m.link_delayed = False
        m.last_heartbeat = 0
        m.last_message = 0
        m.highest_msec = 0
        mpstate.mav_master.append(m)
        mpstate.status.counters['MasterIn'].append(0)

    # log all packets from the master, for later replay
    open_logs()

    # open any mavlink UDP ports
    for p in opts.output:
        if ',' in p and not os.path.exists(p):
            port, baud = p.split(',')            
        else:
            port, baud = p, opts.baudrate

        mpstate.mav_outputs.append(mavutil.mavlink_connection(port, baud=int(baud), input=False))

    if opts.sitl:
        mpstate.sitl_output = mavutil.mavudp(opts.sitl, input=False)

    mpstate.settings.numcells = opts.num_cells
    mpstate.settings.streamrate = opts.streamrate
    mpstate.settings.streamrate2 = opts.streamrate

    mavproxy.msg_period = mavutil.periodic_event(1.0/15)
    mavproxy.heartbeat_period = mavutil.periodic_event(1)
    mavproxy.battery_period = mavutil.periodic_event(0.1)
    mavproxy.heartbeat_check_period = mavutil.periodic_event(0.33)

    mpstate.rl = rline.rline("MAV> ", mpstate)
    if opts.setup:
        mpstate.rl.set_prompt("")

    if 'HOME' in os.environ and not opts.setup:
        start_script = os.path.join(os.environ['HOME'], ".mavinit.scr")
        if os.path.exists(start_script):
            run_script(start_script)

    if opts.aircraft is not None:
        start_script = os.path.join(opts.aircraft, "mavinit.scr")
        if os.path.exists(start_script):
            run_script(start_script)
        else:
            print("no script %s" % start_script)

    if not opts.setup:
        # some core functionality is in modules
        standard_modules = ['log','rally','fence','param','relay',
                            'tuneopt','arm','mode','calibration','rc','wp','auxopt','quadcontrols','test']
        for m in standard_modules:
            load_module(m, quiet=True)

    if opts.console:
        process_stdin('module load console')

    if opts.map:
        process_stdin('module load map')

    for module in opts.load_module:
        modlist = module.split(',')
        for mod in modlist:
            process_stdin('module load %s' % mod)

    if opts.cmd is not None:
        cmds = opts.cmd.split(';')
        for c in cmds:
            process_stdin(c)

# run main loop as a thread
    mpstate.status.thread = threading.Thread(target=main_loop)
    mpstate.status.thread.daemon = True
    mpstate.status.thread.start()