Exemplo n.º 1
0
    def initialize(self):
        """ Initialize the MOOS app. """
        logger.info("MOOS datastream initialize %s"%self)
        
        
        self.moos_host = self.kwargs.get('moos_host', 'localhost')
        self.moos_port = self.kwargs.get('moos_port', 9000)
        self.moos_name = self.kwargs.get('moos_name', self.component_name)
        
        
        '''
        key = (self.moos_host, self.moos_port)

        if not key in AbstractMOOS._moosapps:
            AbstractMOOS._save_messages[key] = []
            AbstractMOOS._moosapps[key] = pymoos.MOOSCommClient.MOOSApp()
            AbstractMOOS._moosapps[key].Run(self.moos_host,
                                            self.moos_port,
                                            "uMorse", 
                                            self.moos_freq)
            logger.info("\tdatastream: host=%s:port=%d (freq: %.2fHz)"
                %(self.moos_host, self.moos_port, self.moos_freq))
            logger.info("\tnew interface initialized")
            '''

        # all instance share the same static MOOSApp according to host and port
        self.comms = pymoos.comms()
        
        self.comms.run(self.moos_host,self.moos_port,self.moos_name)
        self.time = pymoos.time
Exemplo n.º 2
0
 def __init__(self):
     # Open a communication link to MOOS
     self.comms = pymoos.comms()
     # Placeholder for the list of varables that we want
     self.NAV_X = []
     self.NAV_Y = []
     self.NAV_HEAD = []
Exemplo n.º 3
0
 def __init__(self):
     # Open a communication link to MOOS
     self.comms = pymoos.comms()
     # Initialize the MOOS lists
     self.LANDMARKS = []
     self.NAV_AIDS  = []
     self.UNDERWATER = []
Exemplo n.º 4
0
def main(_sigma_q, _sigma_r, _p_d, _p_s):
    global comms, f_gmphd, born_components, auv_nav_status
    comms = pymoos.comms()

    F = [[1, 0], [0, 1]]
    H = [[1, 0], [0, 1]]

    sigma_q = _sigma_q
    sigma_r = _sigma_r

    Q = [[math.pow(sigma_q, 2), 0], [0, math.pow(sigma_q, 2)]]
    R = [[math.pow(2 * sigma_r, 2), 0], [0, math.pow(2 * sigma_r, 2)]]

    p_d = _p_d
    p_s = _p_s

    clutter_intensity = 0
    born_components = []

    f_gmphd = gmphd.GMPHD([], p_s, p_d, F, Q, H, R, clutter_intensity)

    comms.set_on_connect_callback(on_connect)
    comms.set_on_mail_callback(on_mail)
    comms.run('localhost', 9001, 'gmphd-moos')
    while True:
        time.sleep(.01)
Exemplo n.º 5
0
    def __init__(self, sonar_msg_callback=None, waypoints_callback=None):
        """
        :param host: MOOS host name/ip
        :param port: MOOS port
        :param name: Name of program
        """
        # Logger stuff
        super().__init__()
        self.logger = logging.getLogger('messages.MoosMsgs')
        self.logger_bins = logging.getLogger('messages.MoosMsgs.bins')
        self.logger_pose = logging.getLogger('messages.MoosMsgs.pose')
        self.logger.debug('MOOS msgs initiated')

        # Init
        self.comms = pm.comms()
        self.comms.set_on_connect_callback(self.on_connect)
        self.add_queues()

        self.cur_pos_msg = MoosPosMsg()

        self.waypoint_list = None
        self.waypoint_counter = None

        # if LosSettings.enable_los and Settings.enable_autopilot:
        self.los_stop_event = threading.Event()
        self.los_start_event = threading.Event()
        self.los_restart_event = threading.Event()
        self.los_controller = LosController(self, 0.1, self.los_stop_event, self.los_start_event, self.los_restart_event)
        self.los_thread = threading.Thread()  # threading.Thread(target=self.los_controller.loop, daemon=True)
Exemplo n.º 6
0
    def __init__(self):
        self.bathy_grid = gridgen.BathyGrid.from_bathymetry( \
            $(BATHY_GRID), False)

        self.comms = pymoos.comms()
        self.comms.set_on_connect_callback(self.connect_callback)
        self.comms.set_on_mail_callback(self.message_received)
        pymoos.set_moos_timewarp($(WARP))
        self.comms.set_comms_control_timewarp_scale_factor(0.4)
        self.comms.run('localhost', 9000, 'uSonarSimulator')

        # Initialize stored variables
        self.messages = dict()
        self.messages['NAV_X'] = 0
        self.messages['NAV_Y'] = 0
        self.messages['NAV_LAT'] = 0
        self.messages['NAV_LONG'] = 0
        self.messages['NAV_HEADING'] = 0
        self.messages['NEXT_SWATH_SIDE'] = 'stbd'
        self.post_ready = False
        self.post_message = ""
        self.post_stbd = ""
        self.post_port = ""

        self.swath_angle = SWATH_ANGLE
        self.last_port_depth = 0
        self.last_stbd_depth = 0
        self.msg_count = 0
Exemplo n.º 7
0
def main(_sigma_q, _sigma_r, _p_d, _p_s):
    global comms, f_gmphd, born_components, auv_nav_status
    comms = pymoos.comms()

    F = [[1, 0], [0, 1]]
    H = [[1, 0], [0, 1]]

    sigma_q = _sigma_q
    sigma_r = _sigma_r

    Q = [[math.pow(sigma_q, 2), 0], [0, math.pow(sigma_q, 2)]]
    R = [[math.pow(2*sigma_r, 2), 0], [0, math.pow(2*sigma_r, 2)]]

    p_d = _p_d
    p_s = _p_s

    clutter_intensity = 0

    born_components = []

    f_gmphd = gmphd.GMPHD([], p_s, p_d, F, Q, H, R, clutter_intensity)

    comms.set_on_connect_callback(on_connect)
    comms.set_on_mail_callback(on_mail)
    comms.run('localhost', 9001, 'gmphd-moos')
    i = 0
    while True:
        i = i + 1
        time.sleep(.1)
Exemplo n.º 8
0
    def __init__(self):
        self.moos_app_name = 'PySpectrogram'
        self.time_warp = 1
        self.server_host = 'localhost'
        self.server_port = 9000
        self.freq_sampling = 37500.0
        self.num_samples = 16000
        self.num_hydrophones = 5
        self.aco_data = np.zeros(
            (self.num_samples, self.num_hydrophones
             ))  #array that holds the acoustic data currently being processed
        self.aco_data_latest = None  #array that holds new acoustic data while it waits to be processed
        self.aco_new = False  #flag to indicate that new acoustic data has been read
        self.extents = None
        ''' Initialize Python-MOOS Communications '''
        self.mooscomms = pymoos.comms()
        self.mooscomms.set_on_connect_callback(self.moos_on_connect)

        self.mooscomms.add_active_queue(
            'cbf_queue', self.moos_on_new_acoustic_binary_data
        )  #let's use a queue callback instead to handle distinct messages
        self.mooscomms.add_message_route_to_active_queue(
            'cbf_queue', 'DAQ_BINARY_DATA'
        )  #route 'DAQ_BINARY_DATA' messages to moos_on_new_acoustic_binary_data function

        self.mooscomms.run(self.server_host, self.server_port,
                           self.moos_app_name)
        pymoos.set_moos_timewarp(self.time_warp)
Exemplo n.º 9
0
    def test_10_notify_msg(self):
        c = pymoos.comms()
        c.set_on_connect_callback(
            lambda: self.assertTrue(c.register('TEST_NOTIFY_MSG')))
        c.run('localhost', 9000, 'test_notify_msg')
        c.wait_until_connected(5000)
        time.sleep(1)

        self.assertTrue(c.is_registered_for('TEST_NOTIFY_MSG'))

        t = pymoos.time()

        self.assertTrue(c.notify('TEST_NOTIFY_MSG', 1., t))

        time.sleep(1)

        msgs = c.fetch()
        self.assertNotEqual(len(msgs), 0)
        for msg in msgs:
            self.assertEqual(msg.key(), 'TEST_NOTIFY_MSG')
            self.assertEqual(msg.name(), 'TEST_NOTIFY_MSG')
            self.assertTrue(msg.is_name('TEST_NOTIFY_MSG'))
            self.assertEqual(msg.double(), 1)
            self.assertTrue(msg.is_double())
            self.assertEqual(msg.source(), 'test_notify_msg')
            self.assertFalse(msg.is_string())
            self.assertFalse(msg.is_binary())
            self.assertEqual(msg.time(), t)

        c.close(True)
Exemplo n.º 10
0
 def __init__(self):
     # Open a communication link to MOOS
     self.comms = pymoos.comms()
     self.All_ang = []
     self.util = []
     self.X = []
     self.Y = []
     self.cost = []
Exemplo n.º 11
0
 def __init__(self):
     # Open a communication link to MOOS
     self.comms = pymoos.comms()
     self.X = []
     self.Y = []
     self.Index = []
     self.New_Pnt = []
     self.New_Poly = []
Exemplo n.º 12
0
    def test_01_name(self):
        c = pymoos.comms()
        c.run('localhost', 9000, 'test_name')
        c.wait_until_connected(2000)

        self.assertEqual(c.get_moos_name(), 'test_name')
        self.assertEqual(c.get_community_name(), 'pymoos_test_db')

        c.close(True)
Exemplo n.º 13
0
 def __init__(self):
     # Open a communication link to MOOS
     self.comms = pymoos.comms()
     self.WPT = []
     self.poly = []
     self.point =[]
     self.heading = []
     self.angles = []
     self.util = []
     self.buffer_width = []
Exemplo n.º 14
0
 def __init__(self, fname):
     # Init
     self.comms = pm.comms()
     self.fname = fname
     self.f = open(fname, 'r')
     self.reader = csv.DictReader(self.f,
                                  fieldnames=[
                                      'time', 'key', 'type', 'bearing',
                                      'step', 'range_scale', 'length',
                                      'dbytes', 'data'
                                  ])
Exemplo n.º 15
0
    def test_12_get_registered(self):
        c = pymoos.comms()
        c.run('localhost', 9000, 'test_get_registered')
        c.wait_until_connected(2000)

        c.register('MOOS_UPTIME', 0.)
        c.register('MOOS_UPTIME2', 0.)

        self.assertSetEqual(c.get_registered(),
                            {'MOOS_UPTIME', 'MOOS_UPTIME2'})

        c.close(True)
Exemplo n.º 16
0
    def test_30_on_connect_callback_inline(self):
        c = pymoos.comms()
        c.set_on_connect_callback(
            lambda: self.assertTrue(c.register('TEST_ON_CALLBACK_I')))
        c.run('localhost', 9000, 'test_on_connect_callback_inline')
        c.wait_until_connected(2000)

        time.sleep(1)

        self.assertTrue(c.is_registered_for('TEST_ON_CALLBACK_I'))

        c.close(True)
Exemplo n.º 17
0
    def test_13_is_registered_for(self):
        c = pymoos.comms()
        c.run('localhost', 9000, 'test_is_registered_for')
        c.wait_until_connected(2000)

        self.assertFalse(c.is_registered_for('MOOS_UPTIME'))

        c.register('MOOS_UPTIME', 0.)

        self.assertTrue(c.is_registered_for('MOOS_UPTIME'))
        self.assertFalse(c.is_registered_for('MOOS_UPTIME2'))

        c.close(True)
Exemplo n.º 18
0
    def __init__(self, topic, proto):
        self.topic = topic
        self.proto = proto
        # TODO: set up MOOS subscription to variable
        # TODO: Set up protobuf decoding

        self.comms = pymoos.comms()
        self.comms.set_on_connect_callback(self.on_connect)
        queue_name = "echo_queue"
        self.comms.add_active_queue(queue_name, self.msg_callback)
        self.comms.add_message_route_to_active_queue(queue_name, self.topic)
        # Args are: server, port, my_name
        self.comms.run('localhost', 9000, 'moostopic_echo')
Exemplo n.º 19
0
 def __init__(self, fname):
     # Init
     self.comms = pm.comms()
     self.comms.set_on_connect_callback(self.on_connect)
     self.add_queues()
     self.fname = fname
     self.f = open(fname, 'w')
     self.writer = csv.DictWriter(self.f,
                                  fieldnames=[
                                      'time', 'key', 'type', 'bearing',
                                      'step', 'range_scale', 'length',
                                      'dbytes', 'data'
                                  ])
Exemplo n.º 20
0
    def test_31_on_connect_callback(self):
        logger.debug(' on ')
        c = pymoos.comms()

        def on_connect():
            logger.debug(' on ')
            self.assertTrue(c.register('TEST_ON_CALLBACK', 0))
            return True

        c.set_on_connect_callback(on_connect)
        c.run('localhost', 9000, 'test_on_connect_callback')
        c.wait_until_connected(2000)
        time.sleep(.1)

        self.assertTrue(c.is_registered_for('TEST_ON_CALLBACK'))

        c.close(True)
Exemplo n.º 21
0
  def __init__(self):

    self._x = 0.0
    self._y = 0.0
    self._z = 0.0
    self._h = 0.0

    #Bathy Sim
    self.sim = BathySim(123)

    #MOOS
    self._moos = pymoos.comms()
    self._moos.set_on_connect_callback(self.on_connect)
    self._moos.set_on_mail_callback(self.on_mail)

    self._update = False
    self._logfile = None
    self._file_label = ""
Exemplo n.º 22
0
    def test_00_run_close(self):
        c = pymoos.comms()

        self.assertFalse(c.is_connected())
        self.assertFalse(c.is_running())

        c.run('localhost', 9000, 'test_run_close')

        self.assertTrue(c.is_running())

        # sleep for a little to make sure we have time to connect
        c.wait_until_connected(2000)

        self.assertTrue(c.is_connected())
        self.assertTrue(c.is_asynchronous())

        c.close(True)

        self.assertFalse(c.is_connected())
        self.assertFalse(c.is_running())
Exemplo n.º 23
0
    def __init__(self):
        self.moos_app_name = 'PySpectrogram'
        self.time_warp = 1
        self.server_host = 'localhost'
        self.server_port = 9000
        self.freq_sampling = 37500.0
        self.num_samples = 16000
        self.num_hydrophones = 5
        self.aco_data = np.zeros((self.num_samples, self.num_hydrophones))  #array that holds the acoustic data currently being processed
        self.aco_data_latest = None                                         #array that holds new acoustic data while it waits to be processed
        self.aco_new = False                                                #flag to indicate that new acoustic data has been read
        self.extents = None

        ''' Initialize Python-MOOS Communications '''
        self.mooscomms = pymoos.comms()
        self.mooscomms.set_on_connect_callback(self.moos_on_connect)
        
        self.mooscomms.add_active_queue('cbf_queue', self.moos_on_new_acoustic_binary_data) #let's use a queue callback instead to handle distinct messages
        self.mooscomms.add_message_route_to_active_queue('cbf_queue', 'DAQ_BINARY_DATA')    #route 'DAQ_BINARY_DATA' messages to moos_on_new_acoustic_binary_data function

        self.mooscomms.run(self.server_host, self.server_port, self.moos_app_name)
        pymoos.set_moos_timewarp(self.time_warp)
Exemplo n.º 24
0
    def test_32_on_mail_callback(self):
        logger.debug(' on ')
        c = pymoos.comms()
        self.received_mail = False

        def on_connect():
            logger.debug(' on ')
            self.assertTrue(c.register('TEST_CALLBACK_ONMAIL_VAR', 0))
            return True

        def on_new_mail():
            logger.debug(' on ')
            for msg in c.fetch():
                logger.debug(' one new mail ')
                self.assertTrue(msg.is_name('TEST_CALLBACK_ONMAIL_VAR'))
                self.assertEqual(msg.double(), 1)
                self.received_mail = True
                logger.debug(' mail processed ')
            return True

        c.set_on_connect_callback(on_connect)
        c.set_on_mail_callback(on_new_mail)
        c.run('localhost', 9000, 'test_on_mail_callback')
        c.wait_until_connected(2000)

        time.sleep(1)

        self.assertTrue(c.is_registered_for('TEST_CALLBACK_ONMAIL_VAR'))
        self.assertFalse(self.received_mail)
        self.assertTrue(c.notify('TEST_CALLBACK_ONMAIL_VAR', 1, -1))

        time.sleep(1)

        self.assertTrue(self.received_mail)

        c.close(True)
Exemplo n.º 25
0
 def __init__(self):
     # Open a communication link to MOOS
     self.comms = pymoos.comms()
     self.Des_Heading = []
     self.Rudder = []
     self.Heading = []
Exemplo n.º 26
0
    def __init__(self):
        self.comms = pymoos.comms()
        self.comms.set_on_connect_callback(self.connect_callback)
        self.comms.set_on_mail_callback(self.message_received)
        pymoos.set_moos_timewarp($(WARP))
        self.comms.set_comms_control_timewarp_scale_factor(0.4)
        self.comms.run('localhost', 9000, 'pPathPlan')

        # Initialize stored variables
        self.messages = dict()
        self.messages['SWATH_EDGE'] = ''
        self.messages['SWATH_WIDTH_RECORD'] = ''
        self.messages['NEXT_SWATH_SIDE'] = 'stbd'
        self.messages['TURN_REACHED'] = 'false'
        self.post_ready = False
        self.post_message = ''
        self.turn_pt_message = ''
        self.start_line_message = ''
        self.need_to_process = False
        self.post_next_turn = False
        self.post_end = False
        self.turn_count = 0
        # self.op_poly = [(16,-45), (50,-150), \
        #     (-85, -195), (-122, -70)]
        # SH 15 North Survey area:
        # self.op_poly = [(4075.0, -650.0), (3293, -2464), (2405, -2259), \
        #     (3180, -387)]
        # SH15 South Survey Area:
        # self.op_poly = [(2497.0, -4374.0), (1727, -6077), (588, -5468), \
             # (1272, -3864)]
        # Small region for half step testing, SH 2015
        # self.op_poly = [(655, -4429), (550, -4813), (198, -4725), (300, -4353)]
        self.op_poly = $(OP_POLY)
        
        # Newport, RI
        #self.op_poly = [ (-229,47), (-279,217), (-41,264), (0,100)]
    	# South of Pier
        #self.op_poly = [ (-167, -194), (-136, -342), (199, -255), (142, -107) ]
    	# Smaller South of Pier
    	# self.op_poly = [ (-210, -192), (-191,-307), (10,-254), (-16,-144)]

        # VIEW_SEGLIST = "pts={10,-26:16,-45},label=emily_waypt_line_start,
        # label_color=white,edge_color=white,vertex_color=dodger_blue,
        # vertex_size=3,edge_size=1"

        pts_list = [str(pt[0]) + ',' + str(pt[1]) + ':' for pt in self.op_poly]
        # Back to the beginning
        pts_list.append(str(self.op_poly[0][0]) + ',' + str(self.op_poly[0][1]))
        pts_string = ''.join(pts_list)
        region_message = 'pts={' + pts_string + '},label=op_region,' + \
        'label_color=red,edge_color=red,vertex_color=red,edge_size=2'

        # Make sure we can send the message
        if self.comms.wait_until_connected(2000):
            print 'Posting op region: ' + pts_string
            self.comms.notify('VIEW_SEGLIST', region_message, pymoos.time())
            print('Updating lines')
            # Put these in a function
            point_list = [str(pt[0]) + ',' + str(pt[1]) + ':' for pt in self.op_poly[0:2]]
            points_message = ''.join(point_list)
            points_message = 'points=' + points_message[:-1]
            self.comms.notify('SURVEY_UPDATE', points_message, pymoos.time())

            start_heading = (self.op_poly[0][0] - self.op_poly[1][0], \
                self.op_poly[0][1] - self.op_poly[1][1])
            start_heading = pathplan.unit_vector(start_heading)
            start_line_message = 'points=' + \
                str(self.op_poly[0][0] + start_heading[0] * ALIGNMENT_LINE_LEN) + ',' \
                + str(self.op_poly[0][1] + start_heading[1] * ALIGNMENT_LINE_LEN) + \
                ':' + str(self.op_poly[0][0]) + ',' + str(self.op_poly[0][1])
            self.comms.notify('START_UPDATE', start_line_message, pymoos.time())

            end_heading = (self.op_poly[1][0] - self.op_poly[0][0], \
                self.op_poly[1][1] - self.op_poly[0][1])
            end_heading = pathplan.unit_vector(end_heading)
            turn_pt_message = 'point=' + \
                str(self.op_poly[1][0] + end_heading[0] * TURN_PT_OFFSET) + ',' \
                + str(self.op_poly[1][1] + end_heading[1] * TURN_PT_OFFSET)
            self.comms.notify('TURN_UPDATE', turn_pt_message, pymoos.time())

            home_message = 'station_pt = ' + str(self.op_poly[0][0] + \
                start_heading[0] * 30) + ',' + str(self.op_poly[0][1] + \
                start_heading[1] * 30)
            self.comms.notify('HOME_UPDATE', home_message, pymoos.time())


            # move boat to start
            # self.comms.notify('NAV_X', str(self.op_poly[0][0] + \
            #     start_heading[0] * 30), pymoos.time())
            # self.comms.notify('NAV_Y', str(self.op_poly[0][1] + \
            #     start_heading[1] * 30), pymoos.time())

            # pdb.set_trace()

        else:
            print 'Timed out connecting before sending op region'
Exemplo n.º 27
0
    root.after(1000, Refresher)


##---------------------------------------------------------------------------##
# Register for updates of the MOOS variables Landmarks and Nav_Aids once every
#   second
##---------------------------------------------------------------------------##
def on_connect():
    comms.register('Landmarks', 0)
    comms.register('Nav_Aids', 0)
    comms.register('Underwater_Objects', 0)
    return True


# Initialize the MOOS connection and communication
comms = pymoos.comms()
comms.set_on_connect_callback(on_connect)
comms.run('localhost', 9000, 'Camera')

# Declare the MOOS lists as GLOBALS
global LANDMARKS
global NAV_AIDS
global UNDERWATER

# Initialize the MOOS lists
LANDMARKS = []
NAV_AIDS = []
UNDERWATER = []

# Run the GUI - it updates with new MOOS Variables every second
root = tk.Tk()
Exemplo n.º 28
0
    def __init__(self, sonar_port, pos_port, autopilot_ip,
                 autopilot_server_port, autopilot_listen_port):
        super().__init__()
        # Logger stuff
        super().__init__()
        self.logger = logging.getLogger('messages.moosClient')
        self.logger_bins = logging.getLogger('messages.moosClient.bins')
        self.logger_pose = logging.getLogger('messages.moosClient.pose')
        self.logger.debug('MOOS msgs initiated')

        # Init
        self.comms = pm.comms()
        self.comms.set_on_connect_callback(self.on_connect)
        self.add_queues()

        self.buffer_lock = threading.Lock()
        self.sonar_update_thread = None

        self.sonar_server = socketserver.UDPServer(
            ('0.0.0.0', sonar_port), handler_factory(self.parse_sonar_msg))
        self.sonar_server.allow_reuse_address = True
        self.sonar_thread = threading.Thread(
            target=self.sonar_server.serve_forever, daemon=True)

        if Settings.pos_msg_source == 0:
            self.pos_server = socketserver.UDPServer(
                ('0.0.0.0', pos_port), handler_factory(self.parse_pos_msg))
            self.pos_thread = threading.Thread(
                target=self.pos_server.serve_forever, daemon=True)
        else:
            self.pos_stop_event = threading.Event()
            self.pos_thread = Wathdog(self.pos_stop_event,
                                      self.get_pos,
                                      Settings.pos_update_speed / 1000.0,
                                      daemon=True)

        if CollisionSettings.send_new_wps:
            self.autopilot_watchdog_stop_event = threading.Event()
            self.autopilot_watchdog_thread = Wathdog(
                self.autopilot_watchdog_stop_event,
                self.ping_autopilot_server,
                ConnectionSettings.autopilot_watchdog_timeout,
                daemon=True)
            self.ap_pos_received = threading.Event()
            self.guidance_mode = None

        if autopilot_listen_port is not None and Settings.enable_autopilot:
            self.autopilot_server = socketserver.UDPServer(
                ('0.0.0.0', autopilot_listen_port),
                handler_factory(self.parse_autopilot_msg))
            self.autopilot_thread = threading.Thread(
                target=self.autopilot_server.serve_forever, daemon=True)
        if LosSettings.enable_los and Settings.enable_autopilot:
            self.los_stop_event = threading.Event()
            self.los_start_event = threading.Event()
            self.los_restart_event = threading.Event()
            self.los_controller = LosController(self, 0.1, self.los_stop_event,
                                                self.los_start_event,
                                                self.los_restart_event)
            self.los_thread = threading.Thread(
            )  # threading.Thread(target=self.los_controller.loop, daemon=True)
Exemplo n.º 29
0
# Python-MOOS Bridge
import pymoos

# Used for delays
import time

# pyproj is a library that converts lat long coordinates into UTM
import pyproj 

# GDAL is a library that reads and writes shapefiles
from osgeo import ogr

# Numpy is a useful tool for mathematical operations 
import numpy as np

comms = pymoos.comms()

#==============================================================================
## Initialize some global variables
#==============================================================================
# Calculate the origin 
LonLat2UTM = pyproj.Proj(proj='utm', zone=19, ellps='WGS84')

LatOrigin  = 43.071959194444446
LongOrigin = -70.711610833333339 
x_origin,y_origin = LonLat2UTM(LongOrigin, LatOrigin)

#==============================================================================
# Convert MOOS x,y to Longitude and Latitude
#==============================================================================
def MOOSxy2LonLat(x, y):
Exemplo n.º 30
0
 def __init__(self):
     # Open a communication link to MOOS
     self.comms = pymoos.comms()
Exemplo n.º 31
0
    def test_20_zmsg_types(self):
        x = bytearray([0, 3, 0x15, 2, 6, 0xAA])
        s = 'hello'
        d = 384.653
        c = pymoos.comms()

        def on_connect():
            self.assertTrue(c.register('TEST_STRING_VAR', 0))
            self.assertTrue(c.register('TEST_DOUBLE_VAR', 0))
            self.assertTrue(c.register('TEST_BINARY_VAR', 0))
            return True

        c.set_on_connect_callback(on_connect)

        c.run('localhost', 9000, 'test_zmsg_types')
        c.wait_until_connected(2000)

        self.assertTrue(c.is_registered_for('TEST_STRING_VAR'))
        self.assertTrue(c.is_registered_for('TEST_DOUBLE_VAR'))
        self.assertTrue(c.is_registered_for('TEST_BINARY_VAR'))
        t = pymoos.time()

        self.assertTrue(c.notify('TEST_STRING_VAR', s, t))
        self.assertTrue(c.notify('TEST_DOUBLE_VAR', d, t))
        self.assertTrue(c.notify_binary('TEST_BINARY_VAR', str(x), t))

        time.sleep(1)

        idx = 0
        logger.debug('idx hit')
        msgs = c.fetch()
        logger.debug('fetch hit')
        self.assertNotEqual(len(msgs), 0)
        self.assertEqual(len(msgs), 3)
        for msg in msgs:
            logger.debug('iter hit')
            self.assertEqual(msg.time(), t)
            logger.debug('time hit')
            if msg.key() == 'TEST_STRING_VAR':
                logger.debug('string hit')
                self.assertTrue(msg.is_string())
                self.assertEqual(msg.string(), s)
                self.assertFalse(msg.is_double())
                self.assertFalse(msg.is_binary())
            elif msg.key() == 'TEST_DOUBLE_VAR':
                logger.debug('double hit')
                self.assertTrue(msg.is_double())
                self.assertEqual(msg.double(), d)
                self.assertFalse(msg.is_string())
                self.assertFalse(msg.is_binary())
            elif msg.key() == 'TEST_BINARY_VAR':
                logger.debug('binary hit')
                self.assertTrue(msg.is_binary())
                self.assertEqual(str(msg.binary_data()), str(x))
                self.assertTrue(msg.is_string())
                self.assertFalse(msg.is_double())

            idx += 1
            logger.debug('idx++ hit')

        self.assertEqual(idx, 3)

        c.close(True)
Exemplo n.º 32
0
    def test_33_on_mail_active_queues(self):
        logger.debug(' on ')
        c = pymoos.comms()
        self.received_mail = False
        self.received_mail_q_v1 = False
        self.received_mail_q_v2 = False
        self.received_mail_q2_v = False

        def on_connect():
            logger.debug(' on ')
            self.assertTrue(c.register('TEST_ONMAIL_ACTIVE_Q', 0))
            self.assertTrue(c.register('TEST_ONQUEUE_VAR1', 0))
            self.assertTrue(c.register('TEST_ONQUEUE_VAR2', 0))
            self.assertTrue(c.register('TEST_ONQUEUE2_VAR', 0))
            return True

        def on_new_mail_aq():
            logger.debug(' on ')
            for msg in c.fetch():
                logger.debug(' one new mail = ' + msg.key())
                # self.assertTrue(msg.is_name('TEST_ONMAIL_ACTIVE_Q'))
                # self.assertEqual(msg.double(), 1)
                self.received_mail = True
                logger.debug(' mail processed')
            return True

        def queue1(msg):
            logger.debug(' on ')
            if msg.is_name('TEST_ONQUEUE_VAR1'):
                self.assertEqual(msg.double(), 2)
                self.received_mail_q_v1 = True
            elif msg.is_name('TEST_ONQUEUE_VAR2'):
                self.assertEqual(msg.double(), 3)
                self.received_mail_q_v2 = True
            return True

        def queue2(msg):
            logger.debug(' on ')
            if msg.is_name('TEST_ONQUEUE2_VAR'):
                self.assertEqual(msg.double(), 4)
                self.received_mail_q2_v = True
            return True

        c.set_on_connect_callback(on_connect)
        c.set_on_mail_callback(on_new_mail_aq)
        c.add_active_queue('queue1', queue1)
        c.add_message_route_to_active_queue('queue1', 'TEST_ONQUEUE_VAR1')
        c.add_message_route_to_active_queue('queue1', 'TEST_ONQUEUE_VAR2')
        c.add_active_queue('queue2', queue2)
        c.add_message_route_to_active_queue('queue2', 'TEST_ONQUEUE2_VAR')
        c.run('localhost', 9000, 'test_on_mail_active_queues')
        c.wait_until_connected(5000)

        time.sleep(1)

        self.assertTrue(c.is_registered_for('TEST_ONMAIL_ACTIVE_Q'))
        self.assertTrue(c.is_registered_for('TEST_ONQUEUE_VAR1'))
        self.assertTrue(c.is_registered_for('TEST_ONQUEUE_VAR2'))
        self.assertTrue(c.is_registered_for('TEST_ONQUEUE2_VAR'))
        self.assertFalse(self.received_mail)
        self.assertFalse(self.received_mail_q_v1)
        self.assertFalse(self.received_mail_q_v2)
        self.assertFalse(self.received_mail_q2_v)
        self.assertTrue(c.notify('TEST_ONMAIL_ACTIVE_Q', 1))
        self.assertTrue(c.notify('TEST_ONQUEUE_VAR1', 2))
        self.assertTrue(c.notify('TEST_ONQUEUE_VAR2', 3))
        self.assertTrue(c.notify('TEST_ONQUEUE2_VAR', 4))

        time.sleep(1)

        self.assertTrue(self.received_mail)
        self.assertTrue(self.received_mail_q_v1)
        self.assertTrue(self.received_mail_q_v2)
        self.assertTrue(self.received_mail_q2_v)

        c.close(True)