Esempio n. 1
0
class RelayService:
    def __init__(self, url, username, password):
        self.client = AsyncClient(
            url=url,
            username=username,
            password=password,
        )
        self.last_telemetry = time()

    def telemetry(self, lat, lon, alt, heading):
        t = Telemetry(latitude=lat,
                      longitude=lon,
                      altitude_msl=alt,
                      uas_heading=heading)
        self.client.post_telemetry(t)

        new_time = time()
        print 1/(new_time-self.last_telemetry)
        self.last_telemetry = new_time

        return True

    def server_info(self):
        info = self.client.get_server_info().result()
        return str(info.message)
Esempio n. 2
0
class RelayService:
    def __init__(self, url, username, password):
        self.client = AsyncClient(url=url,
                                  username=username,
                                  password=password)
        self.last_telemetry = time()

    def telemetry(self, lat, lon, alt, heading):
        t = Telemetry(latitude=lat,
                      longitude=lon,
                      altitude_msl=alt,
                      uas_heading=heading)
        self.client.post_telemetry(t)

        new_time = time()
        print(1 / (new_time - self.last_telemetry))
        self.last_telemetry = new_time

        return True

    def get_obstacles(self):
        async_future = self.client.get_obstacles()
        async_stationary, async_moving = async_future.result()
        #print("here")
        # stat_ob, moving_ob = self.client.get_obstacles()
        async_radii_stationary = [o.cylinder_radius for o in async_stationary]
        async_lat_stationary = [o.latitude for o in async_stationary]
        async_lng_stationary = [o.longitude for o in async_stationary]
        async_height_stationary = [o.cylinder_height for o in async_stationary]
        async_radii_moving = [o.sphere_radius for o in async_moving]
        async_lat_moving = [o.latitude for o in async_moving]
        async_lng_moving = [o.longitude for o in async_moving]
        async_height_moving = [o.altitude_msl for o in async_moving]
        
        return async_radii_stationary, async_lat_stationary, async_lng_stationary, async_height_stationary, async_radii_moving, async_lat_moving, async_lng_moving, async_height_moving
	
	def get_moving_obstacles(self):
	
		return True

    def server_info(self):
        info = self.client.get_server_info().result()
        return str(info.message), str(info.message_timestamp), str(info.server_time)
Esempio n. 3
0
class Telemetria(mp_module.MPModule):
    def __init__(self, mpstate):
        super(Telemetria, self).__init__(mpstate, "telemetria",
                                         "telemetria module")
        self.add_command('zrobCos', self.cmd_zrobCos, "zrobCos commands")
        self.client = AsyncClient(INTEROP_URL, INTEROP_USERNAME,
                                  INTEROP_PASSWORD)

    def mavlink_packet(self, m):
        '''handle a mavlink packet'''
        if m.get_type() == 'GLOBAL_POSITION_INT':
            telemetry = Telemetry(
                float(m.lat) / 10000000,
                float(m.lon) / 10000000,
                float(m.alt) / 1000,
                float(m.hdg) / 100)
            self.client.post_telemetry(telemetry)

    def cmd_zrobCos(self, args):
        print "Niby co"
Esempio n. 4
0
class RelayService:
    def __init__(self, url, username, password):
        self.client = AsyncClient(url=url,
                                  username=username,
                                  password=password)
        self.last_telemetry = time()

    def telemetry(self, lat, lon, alt, heading):
        t = Telemetry(latitude=lat,
                      longitude=lon,
                      altitude_msl=alt,
                      uas_heading=heading)
        self.client.post_telemetry(t)

        new_time = time()
        print(1 / (new_time - self.last_telemetry))
        self.last_telemetry = new_time

        return True

    def server_info(self):
        info = self.client.get_server_info().result()
        return str(info.message)
Esempio n. 5
0
class RelayService:
    def __init__(self, url, username, password):
        self.client = AsyncClient(url=url,
                                  username=username,
                                  password=password)
        self.last_telemetry = time()

    def telemetry(self, lat, lon, alt, heading):
        t = Telemetry(latitude=lat,
                      longitude=lon,
                      altitude_msl=alt,
                      uas_heading=heading)
        self.client.post_telemetry(t)

        new_time = time()
        print(1 / (new_time - self.last_telemetry))
        self.last_telemetry = new_time

        return True

    # POSTs target data, where target is a json object conforming to the
    # interop Target class specifications
    def target_data(self, target):
        # the ** operator unwraps the dictionary (here a json object)
        # into an actual argument list, and then we use that to create
        # an instance of the interop Target class
        t = Target(**target)
        self.client.post_target(t)

    # GETs all target info as a json object and prints it
    def get_target_data(self):
        return str(self.client.get_targets().result())

    def server_info(self):
        info = self.client.get_server_info().result()
        return str(info.server_time)
Esempio n. 6
0
def main(url,
         username,
         password,
         interop_time,
         generator,
         flightsim_kml_path=None):
    """Probes the interop server.

    Args:
        url: The interoperability URL.
        username: The interoperability username.
        password: The interoperability password.
        interop_time: The time between interop requests.
        generator: The data generator name to use.
        flightsim_kml_path: The KML path to use if flightsim generator.
    """
    # Create client and data generator.
    client = AsyncClient(url, username, password)
    if generator == 'zeros':
        data_generator = datagen.ZeroValueGenerator()
    else:
        data_generator = flightsim.KmlGenerator(flightsim_kml_path)

    # Continually execute interop requests until signaled to stop.
    while True:
        start_time = datetime.datetime.now()
        telemetry = data_generator.get_uas_telemetry(start_time)

        telemetry_resp = client.post_telemetry(telemetry)
        obstacle_resp = client.get_obstacles()
        telemetry_resp.result()
        obstacle_resp.result()

        end_time = datetime.datetime.now()
        elapsed_time = (end_time - start_time).total_seconds()
        logging.info('Executed interop. Total latency: %f', elapsed_time)

        delay_time = interop_time - elapsed_time
        if delay_time > 0:
            try:
                time.sleep(delay_time)
            except KeyboardInterrupt:
                sys.exit(0)
Esempio n. 7
0
# Tracks upload success and prints any exceptions.
def handle_upload_result(future):
    if future.exception():
        print 'Request Failed. Exception: %s' % str(future.exception())
    else:
        with sent_lock:
            sent_since_print += 1

# Continuously poll for new telemetry and send to server.
last_telemetry = Telemetry(0, 0, 0, 0)
while True:
    telemetry = Telemetry(latitude=cs.lat,
                          longitude=cs.lng,
                          altitude=cs.alt,
                          uas_heading=cs.groundcourse)
    if telemetry != last_telemetry:
        client.post_telemetry(telemetry).add_done_callback(
            handle_upload_result)
        last_telemetry = telemetry

    now = datetime.datetime.now()
    since_print = (now - last_print).total_seconds()
    if since_print >= PRINT_SEC:
        with sent_lock:
            local_sent_since_print = sent_since_print
            sent_since_print = 0
        print 'Upload Rate: %f' % (local_sent_since_print / since_print)
        last_print = now

    time.sleep(POLL_SEC)