def __init__(self, receiver, server, outputs, freq):
self.receiver = receiver
self.server = server
self.outputs = outputs
self.freq = freq
self.aircraft = {}
self.requested_traffic = set()
self.df_handlers = {
-1: self.received_clock_reset_marker,
0: self.received_df_misc,
4: self.received_df_misc,
5: self.received_df_misc,
16: self.received_df_misc,
20: self.received_df_misc,
21: self.received_df_misc,
11: self.received_df11,
17: self.received_df17
}
self.next_report = None
self.next_stats = monotonic_time() + self.stats_interval
self.next_profile = monotonic_time()
receiver.coordinator = self
server.coordinator = self
def run_until(self, termination_condition):
try:
next_heartbeat = monotonic_time() + 0.5
next_server_send = monotonic_time()
while not termination_condition():
# maybe there are no active sockets and
# we're just waiting on a timeout
if asyncore.socket_map:
asyncore.loop(timeout=0.1, count=5)
else:
time.sleep(0.5)
now = monotonic_time()
if now >= next_heartbeat:
next_heartbeat = now + 0.5
self.heartbeat(now)
if now >= next_server_send:
self.server_send = 1
next_server_send = now + 0.25
finally:
self.receiver.disconnect('Client shutting down')
self.server.disconnect('Client shutting down')
for o in self.outputs:
o.disconnect('Client shutting down')
def __init__(self, receiver, server, outputs, freq):
self.receiver = receiver
self.server = server
self.outputs = outputs
self.freq = freq
self.aircraft = {}
self.requested_traffic = set()
self.reported = set()
self.df_handlers = {
_modes.DF_EVENT_MODE_CHANGE: self.received_mode_change_event,
_modes.DF_EVENT_EPOCH_ROLLOVER: self.received_epoch_rollover_event,
_modes.DF_EVENT_TIMESTAMP_JUMP: self.received_timestamp_jump_event,
0: self.received_df_misc,
4: self.received_df_misc,
5: self.received_df_misc,
16: self.received_df_misc,
20: self.received_df_misc,
21: self.received_df_misc,
11: self.received_df11,
17: self.received_df17
}
self.next_report = None
self.next_stats = monotonic_time() + self.stats_interval
self.next_profile = monotonic_time()
self.next_aircraft_update = self.last_aircraft_update = monotonic_time(
)
self.recent_jumps = 0
receiver.coordinator = self
server.coordinator = self
def __init__(self, receiver, server, outputs, freq):
self.receiver = receiver
self.server = server
self.outputs = outputs
self.freq = freq
self.aircraft = {}
self.requested_traffic = set()
self.reported = set()
self.df_handlers = {
_modes.DF_EVENT_MODE_CHANGE: self.received_mode_change_event,
_modes.DF_EVENT_EPOCH_ROLLOVER: self.received_epoch_rollover_event,
_modes.DF_EVENT_TIMESTAMP_JUMP: self.received_timestamp_jump_event,
0: self.received_df_misc,
4: self.received_df_misc,
5: self.received_df_misc,
16: self.received_df_misc,
20: self.received_df_misc,
21: self.received_df_misc,
11: self.received_df11,
17: self.received_df17
}
self.next_report = None
self.next_stats = monotonic_time() + self.stats_interval
self.next_profile = monotonic_time()
self.next_aircraft_update = self.last_aircraft_update = monotonic_time()
self.recent_jumps = 0
receiver.coordinator = self
server.coordinator = self
def periodic_stats(self, now):
log('Receiver status: {0}', self.receiver.state)
log('Server status: {0}', self.server.state)
global_stats.log_and_reset()
adsb_req = adsb_total = modes_req = modes_total = 0
now = monotonic_time()
for ac in self.aircraft.values():
if ac.messages < 2:
continue
if now - ac.last_position_time < self.position_expiry_age:
adsb_total += 1
if ac.requested:
adsb_req += 1
else:
modes_total += 1
if ac.requested:
modes_req += 1
log('Aircraft: {modes_req} of {modes_total} Mode S, {adsb_req} of {adsb_total} ADS-B used',
modes_req=modes_req,
modes_total=modes_total,
adsb_req=adsb_req,
adsb_total=adsb_total)
if self.recent_jumps > 0:
log('Out-of-order timestamps: {recent}', recent=self.recent_jumps)
self.recent_jumps = 0
def start_connection(self):
log('Connected to multilateration server at {0}:{1}, handshaking',
self.host, self.port)
self.state = 'handshaking'
self.last_data_received = monotonic_time()
compress_methods = ['none']
if self.offer_zlib:
compress_methods.append('zlib')
compress_methods.append('zlib2')
handshake_msg = {
'version': 3,
'client_version': mlat.client.version.CLIENT_VERSION,
'compress': compress_methods,
'selective_traffic': True,
'heartbeat': True,
'return_results': self.return_results,
'udp_transport': 2 if self.offer_udp else False,
'return_result_format': 'ecef'
}
handshake_msg.update(self.handshake_data)
if DEBUG:
log("Handshake: {0}", handshake_msg)
self.writebuf += (json.dumps(handshake_msg) + '\n').encode(
'ascii') # linebuf not used yet
self.consume_readbuf = self.consume_readbuf_uncompressed
self.handle_server_line = self.handle_handshake_response
def periodic_stats(self, now):
global_stats.log_and_reset(self)
adsb_req = adsb_total = modes_req = modes_total = 0
now = monotonic_time()
for ac in self.aircraft.values():
if ac.messages < 2:
continue
if ac.adsb_good:
adsb_total += 1
if ac.requested:
adsb_req += 1
else:
modes_total += 1
if ac.requested:
modes_req += 1
log('Aircraft: {modes_req} of {modes_total} Mode S, {adsb_req} of {adsb_total} ADS-B used',
modes_req=modes_req,
modes_total=modes_total,
adsb_req=adsb_req,
adsb_total=adsb_total)
if self.recent_jumps > 0:
log('Out-of-order timestamps: {recent}', recent=self.recent_jumps)
self.recent_jumps = 0
def handle_read(self):
try:
moredata = self.recv(16384)
except socket.error as e:
if e.errno == errno.EAGAIN:
return
raise
if not moredata:
self.close()
return
global_stats.receiver_rx_bytes += len(moredata)
if self.residual:
moredata = self.residual + moredata
self.last_data_received = monotonic_time()
consumed, messages = self.packetize(moredata, self.last_timestamp)
if consumed < len(moredata):
self.residual = moredata[consumed:]
if len(self.residual) > 5120:
raise RuntimeError('parser broken - buffer not being consumed')
else:
self.residual = None
if messages:
global_stats.receiver_rx_messages += len(messages)
self.last_timestamp = messages[-1].timestamp
self.coordinator.input_received_messages(messages)
def __init__(self, addr, connection_factory):
self.addr = addr
self.connection_factory = connection_factory
self.output_channel = None
self.next_reconnect = monotonic_time()
self.addrlist = []
def start(self, coordinator):
self.coordinator = coordinator
self.reader = AdeptReader(self, coordinator)
self.writer = AdeptWriter(self)
if self.udp_transport:
self.udp_transport.start()
self.send_mlat = self.udp_transport.send_mlat
self.send_sync = self.udp_transport.send_sync
else:
self.send_mlat = self.writer.send_mlat
self.send_sync = self.writer.send_sync
self.send_split_sync = None
self.send_seen = self.writer.send_seen
self.send_lost = self.writer.send_lost
self.send_rate_report = self.writer.send_rate_report
self.send_clock_reset = self.writer.send_clock_reset
self.send_input_connected = self.writer.send_input_connected
self.send_input_disconnected = self.writer.send_input_disconnected
self.state = 'connected'
self.writer.send_ready()
self.next_udp_report = util.monotonic_time() + self.UDP_REPORT_INTERVAL
self.coordinator.server_connected()
def server_connected(self):
self.requested_traffic = set()
self.newly_seen = set()
self.aircraft = {}
self.next_report = monotonic_time() + self.report_interval
if self.receiver.state != 'ready':
self.receiver.reconnect()
def __init__(self, addr, connection_factory):
self.addr = addr
self.connection_factory = connection_factory
self.output_channel = None
self.next_reconnect = monotonic_time()
self.addrlist = []
def start(self, coordinator):
self.coordinator = coordinator
self.reader = AdeptReader(self, coordinator)
self.writer = AdeptWriter(self)
if self.udp_transport:
self.udp_transport.start()
self.send_mlat = self.udp_transport.send_mlat
self.send_sync = self.udp_transport.send_sync
else:
self.send_mlat = self.writer.send_mlat
self.send_sync = self.writer.send_sync
self.send_split_sync = None
self.send_seen = self.writer.send_seen
self.send_lost = self.writer.send_lost
self.send_rate_report = self.writer.send_rate_report
self.send_clock_reset = self.writer.send_clock_reset
self.send_input_connected = self.writer.send_input_connected
self.send_input_disconnected = self.writer.send_input_disconnected
self.state = 'connected'
self.writer.send_ready()
self.next_udp_report = util.monotonic_time() + self.UDP_REPORT_INTERVAL
self.coordinator.server_connected()
def periodic_stats(self, now):
log('Receiver status: {0}', self.receiver.state)
log('Server status: {0}', self.server.state)
global_stats.log_and_reset()
adsb_req = adsb_total = modes_req = modes_total = 0
now = monotonic_time()
for ac in self.aircraft.values():
if ac.messages < 2:
continue
if now - ac.last_position_time < self.position_expiry_age:
adsb_total += 1
if ac.requested:
adsb_req += 1
else:
modes_total += 1
if ac.requested:
modes_req += 1
log('Aircraft: {modes_req} of {modes_total} Mode S, {adsb_req} of {adsb_total} ADS-B used',
modes_req=modes_req,
modes_total=modes_total,
adsb_req=adsb_req,
adsb_total=adsb_total)
if self.recent_jumps > 0:
log('Out-of-order timestamps: {recent}', recent=self.recent_jumps)
self.recent_jumps = 0
def send_position(self, timestamp, addr, lat, lon, alt, callsign, squawk, error_est, nstations):
now = time.time()
line = self.template.format(addr=addr,
rcv_date=format_date(timestamp),
rcv_time=format_time(timestamp),
now_date=format_date(now),
now_time=format_time(now),
callsign=csv_quote(callsign) if callsign else '',
altitude=int(alt),
speed='',
heading='',
lat=round(lat, 4),
lon=round(lon, 4),
vrate='',
squawk=csv_quote(squawk) if squawk else '',
fs='',
emerg='',
ident='',
aog='',
error_est=error_est,
nstations=nstations)
try:
self.send((line + '\n').encode('ascii'))
except socket.error:
self.handle_error()
self.next_heartbeat = monotonic_time() + self.heartbeat_interval
def server_connected(self):
self.requested_traffic = set()
self.newly_seen = set()
self.aircraft = {}
self.reported = set()
self.next_report = monotonic_time() + self.report_interval
if self.receiver.state != 'ready':
self.receiver.reconnect()
def start_connection(self):
log('Input connected to {0}:{1}', self.host, self.port)
self.last_data_received = monotonic_time()
self.state = 'connected'
self.coordinator.input_connected()
# synthesize a mode change immediately if we are not autodetecting
if self.reader.mode is not None:
self.coordinator.input_received_messages((mode_change_event(self.reader),))
def reset(self, now=None):
if now is None:
now = monotonic_time()
self.start = now
self.server_tx_bytes = 0
self.server_rx_bytes = 0
self.server_udp_bytes = 0
self.receiver_rx_bytes = 0
self.receiver_rx_messages = 0
self.mlat_positions = 0
def handle_read(self):
try:
moredata = self.recv(16384)
except socket.error as e:
if e.errno == errno.EAGAIN:
return
raise
if not moredata:
self.close()
return
global_stats.receiver_rx_bytes += len(moredata)
self.coordinator.copy_received_messages(moredata)
if self.residual:
moredata = self.residual + moredata
self.last_data_received = monotonic_time()
try:
consumed, messages, pending_error = self.feed(moredata)
except ValueError as e:
log("Parsing receiver data failed: {e}", e=str(e))
self.reconnect_interval = 5.0
self.close()
return
if consumed < len(moredata):
self.residual = moredata[consumed:]
if len(self.residual) > 5120:
raise RuntimeError('parser broken - buffer not being consumed')
else:
self.residual = None
global_stats.receiver_rx_messages += self.reader.received_messages
global_stats.receiver_rx_filtered += self.reader.suppressed_messages
self.reader.received_messages = self.reader.suppressed_messages = 0
if messages:
self.coordinator.input_received_messages(messages)
if pending_error:
# call it again to get the exception
# now that we've handled all the messages
try:
if self.residual is None:
self.feed(b'')
else:
self.feed(self.residual)
except ValueError as e:
log("Parsing receiver data failed: {e}", e=str(e))
self.close()
return
def start_connection(self):
log('Input connected to {0}:{1}', self.host, self.port)
self.last_data_received = monotonic_time()
self.state = 'connected'
self.coordinator.input_connected()
# synthesize a mode change immediately if we are not autodetecting
if self.reader.mode is not None:
self.coordinator.input_received_messages((mode_change_event(self.reader),))
self.send_settings_message()
def reset(self, now=None):
if now is None:
now = monotonic_time()
self.start = now
self.server_tx_bytes = 0
self.server_rx_bytes = 0
self.server_udp_bytes = 0
self.receiver_rx_bytes = 0
self.receiver_rx_messages = 0
self.receiver_rx_filtered = 0
self.mlat_positions = 0
def update_receiver_filter(self):
now = monotonic_time()
mlat = set()
for icao in self.requested_traffic:
ac = self.aircraft.get(icao)
if not ac or (now - ac.last_position_time > self.position_expiry_age):
# requested, and we have not seen a recent ADS-B message from it
mlat.add(icao)
self.receiver.update_filter(mlat)
def __init__(self, receiver, server, outputs, freq, allow_anon,
allow_modeac):
self.receiver = receiver
self.server = server
self.outputs = outputs
self.freq = freq
self.allow_anon = allow_anon
self.allow_modeac = allow_modeac
self.aircraft = {}
self.requested_traffic = set()
self.requested_modeac = set()
self.reported = set()
self.df_handlers = {
_modes.DF_EVENT_MODE_CHANGE: self.received_mode_change_event,
_modes.DF_EVENT_EPOCH_ROLLOVER: self.received_epoch_rollover_event,
_modes.DF_EVENT_TIMESTAMP_JUMP: self.received_timestamp_jump_event,
_modes.DF_EVENT_RADARCAPE_POSITION:
self.received_radarcape_position_event,
0: self.received_df_misc,
4: self.received_df_misc,
5: self.received_df_misc,
16: self.received_df_misc,
20: self.received_df_misc,
21: self.received_df_misc,
11: self.received_df11,
17: self.received_df17,
_modes.DF_MODEAC: self.received_modeac
}
self.next_report = None
self.next_stats = monotonic_time() + self.stats_interval
self.next_profile = monotonic_time()
self.next_aircraft_update = self.last_aircraft_update = monotonic_time(
)
self.recent_jumps = 0
self.last_jump_message = 0
self.server_send = 1
receiver.coordinator = self
server.coordinator = self
def run_until(self, termination_condition):
try:
next_heartbeat = monotonic_time() + 0.5
while not termination_condition():
# maybe there are no active sockets and
# we're just waiting on a timeout
if asyncore.socket_map:
asyncore.loop(timeout=0.1, count=5)
else:
time.sleep(0.5)
now = monotonic_time()
if now >= next_heartbeat:
next_heartbeat = now + 0.5
self.heartbeat(now)
finally:
self.receiver.disconnect('Client shutting down')
self.server.disconnect('Client shutting down')
for o in self.outputs:
o.disconnect('Client shutting down')
def update_receiver_filter(self):
now = monotonic_time()
mlat = set()
for icao in self.requested_traffic:
ac = self.aircraft.get(icao)
if not ac or not ac.adsb_good:
# requested, and we have not seen a recent ADS-B message from it
mlat.add(icao)
self.receiver.update_filter(mlat)
self.receiver.update_modeac_filter(self.requested_modeac)
def update_receiver_filter(self):
now = monotonic_time()
mlat = set()
for icao in self.requested_traffic:
ac = self.aircraft.get(icao)
if not ac or (now - ac.last_position_time >
self.position_expiry_age):
# requested, and we have not seen a recent ADS-B message from it
mlat.add(icao)
self.receiver.update_filter(mlat)
def handle_read(self):
try:
moredata = self.recv(16384)
except socket.error as e:
if e.errno == errno.EAGAIN:
return
raise
if not moredata:
self.close()
return
global_stats.receiver_rx_bytes += len(moredata)
if self.residual:
moredata = self.residual + moredata
self.last_data_received = monotonic_time()
try:
consumed, messages, pending_error = self.feed(moredata)
except ValueError as e:
log("Parsing receiver data failed: {e}", e=str(e))
self.close()
return
if consumed < len(moredata):
self.residual = moredata[consumed:]
if len(self.residual) > 5120:
raise RuntimeError('parser broken - buffer not being consumed')
else:
self.residual = None
global_stats.receiver_rx_messages += self.reader.received_messages
global_stats.receiver_rx_filtered += self.reader.suppressed_messages
self.reader.received_messages = self.reader.suppressed_messages = 0
if messages:
self.coordinator.input_received_messages(messages)
if pending_error:
# call it again to get the exception
# now that we've handled all the messages
try:
if self.residual is None:
self.feed(b'')
else:
self.feed(self.residual)
except ValueError as e:
log("Parsing receiver data failed: {e}", e=str(e))
self.close()
return
def log_and_reset(self):
now = monotonic_time()
elapsed = now - self.start
log('Receiver: {0:6.1f} msg/s received {1:4.1f}kB/s from receiver',
self.receiver_rx_messages / elapsed,
self.receiver_rx_bytes / elapsed / 1000.0)
log('Server: {0:6.1f} kB/s from server {1:4.1f}kB/s TCP to server {2:4.1f}kB/s UDP to server',
self.server_rx_bytes / elapsed / 1000.0,
self.server_tx_bytes / elapsed / 1000.0,
self.server_udp_bytes / elapsed / 1000.0)
if self.mlat_positions:
log('Results: {0:3.1f} positions/minute',
self.mlat_positions / elapsed * 60.0)
self.reset(now)
def send_position(self, timestamp, addr, lat, lon, alt, nsvel, ewvel,
vrate, callsign, squawk, error_est, nstations, anon,
modeac):
if not self.connected:
return
now = time.time()
if timestamp is None:
timestamp = now
if nsvel is not None and ewvel is not None:
speed = math.sqrt(nsvel**2 + ewvel**2)
heading = math.degrees(math.atan2(ewvel, nsvel))
if heading < 0:
heading += 360
else:
speed = None
heading = None
if modeac:
addrtype = '@'
elif anon:
addrtype = '~'
else:
addrtype = ''
line = self.template.format(
addr=addr,
addrtype=addrtype,
rcv_date=format_date(timestamp),
rcv_time=format_time(timestamp),
now_date=format_date(now),
now_time=format_time(now),
callsign=csv_quote(callsign) if callsign else '',
altitude=int(alt),
speed=int(speed) if (speed is not None) else '',
heading=int(heading) if (heading is not None) else '',
lat=round(lat, 4),
lon=round(lon, 4),
vrate=int(vrate) if (vrate is not None) else '',
squawk=csv_quote(squawk) if (squawk is not None) else '',
fs='',
emerg='',
ident='',
aog='',
error_est=round(error_est, 0) if (error_est is not None) else '',
nstations=nstations if (nstations is not None) else '')
self.send((line + '\n').encode('ascii'))
self.next_heartbeat = monotonic_time() + self.heartbeat_interval
def read_data(self):
while True:
try:
data = self.port.readline()
line = data.decode()
if (line.startswith("$GPGGA")):
rmc = pynmea2.parse(line, check=False)
lon = rmc.longitude
lat = rmc.latitude
alt = rmc.altitude
if (lon == 0 or lat == 0):
continue
if (self.coordinator):
now = monotonic_time()
if now > self.next_update_time:
self.coordinator.gps_position_update_event(
lat, lon, alt)
self.next_update_time = monotonic_time(
) + self.report_interval
except Exception as e:
print(
"Error:Read GPS Serial Port Data Failed! Stop Read!!! ==>",
e)
break
def start_connection(self):
log('Input connected to {0}:{1}', self.host, self.port)
self.last_data_received = monotonic_time()
self.state = 'connected'
self.coordinator.input_connected()
# synthesize a mode change immediately if we are not autodetecting
if self.reader.mode is not None:
self.coordinator.input_received_messages((mode_change_event(self.reader),))
# if we are connected to something that is Beast-like (or autodetecting), send a beast settings message
if self.reader.mode in (None, _modes.BEAST, _modes.RADARCAPE, _modes.RADARCAPE_EMULATED):
# Binary format, no filters, CRC checks enabled, mode A/C disabled
settings_message = b'\x1a1C\x1a1d\x1a1f\x1a1j'
self.send(settings_message)
def send_position(self, timestamp, addr, lat, lon, alt, nsvel, ewvel, vrate,
callsign, squawk, error_est, nstations, anon, modeac):
if not self.connected:
return
now = time.time()
if timestamp is None:
timestamp = now
if nsvel is not None and ewvel is not None:
speed = math.sqrt(nsvel ** 2 + ewvel ** 2)
heading = math.degrees(math.atan2(ewvel, nsvel))
if heading < 0:
heading += 360
else:
speed = None
heading = None
if modeac:
addrtype = '@'
elif anon:
addrtype = '~'
else:
addrtype = ''
line = self.template.format(addr=addr,
addrtype=addrtype,
rcv_date=format_date(timestamp),
rcv_time=format_time(timestamp),
now_date=format_date(now),
now_time=format_time(now),
callsign=csv_quote(callsign) if callsign else '',
altitude=int(alt),
speed=int(speed) if (speed is not None) else '',
heading=int(heading) if (heading is not None) else '',
lat=round(lat, 4),
lon=round(lon, 4),
vrate=int(vrate) if (vrate is not None) else '',
squawk=csv_quote(squawk) if (squawk is not None) else '',
fs='',
emerg='',
ident='',
aog='',
error_est=round(error_est, 0) if (error_est is not None) else '',
nstations=nstations if (nstations is not None) else '')
self.send((line + '\n').encode('ascii'))
self.next_heartbeat = monotonic_time() + self.heartbeat_interval
def schedule_reconnect(self):
if self.reconnect_at is None:
if len(self.addrlist) > 0:
# we still have more addresses to try
# nb: asyncore breaks in odd ways if you try
# to reconnect immediately at this point
# (pending events for the old socket go to
# the new socket) so do it in 0.5s time
# so the caller can clean up the old
# socket and discard the events.
interval = 0.5
else:
interval = self.reconnect_interval
log('Reconnecting in {0} seconds', interval)
self.reconnect_at = monotonic_time() + interval
def schedule_reconnect(self):
if self.reconnect_at is None:
if len(self.addrlist) > 0:
# we still have more addresses to try
# nb: asyncore breaks in odd ways if you try
# to reconnect immediately at this point
# (pending events for the old socket go to
# the new socket) so do it in 0.5s time
# so the caller can clean up the old
# socket and discard the events.
interval = 0.5
else:
interval = self.reconnect_interval
log('Reconnecting in {0} seconds', interval)
self.reconnect_at = monotonic_time() + interval
def received_df_misc(self, message, now):
ac = self.aircraft.get(message.address)
if not ac:
return False # not a known ICAO
ac.messages += 1
ac.last_message_time = monotonic_time()
if ac.messages < 10:
return # wait for more messages
if not ac.requested:
return
# Candidate for MLAT
if now - ac.last_position_time < self.position_expiry_age:
return # reported position recently, no need for mlat
self.server.send_mlat(message)
def handle_read(self):
try:
moredata = self.recv(16384)
except socket.error as e:
if e.errno == errno.EAGAIN:
return
raise
if not moredata:
self.close()
self.schedule_reconnect()
return
self.last_data_received = monotonic_time()
self.readbuf += moredata
global_stats.server_rx_bytes += len(moredata)
self.consume_readbuf()
def log_and_reset(self):
now = monotonic_time()
elapsed = now - self.start
processed = self.receiver_rx_messages - self.receiver_rx_filtered
log('Receiver: {0:6.1f} msg/s received {1:6.1f} msg/s processed ({2:.0f}%)',
self.receiver_rx_messages / elapsed,
processed / elapsed,
0 if self.receiver_rx_messages == 0 else 100.0 * processed / self.receiver_rx_messages)
log('Server: {0:6.1f} kB/s from server {1:4.1f}kB/s TCP to server {2:6.1f}kB/s UDP to server',
self.server_rx_bytes / elapsed / 1000.0,
self.server_tx_bytes / elapsed / 1000.0,
self.server_udp_bytes / elapsed / 1000.0)
if self.mlat_positions:
log('Results: {0:3.1f} positions/minute',
self.mlat_positions / elapsed * 60.0)
self.reset(now)
def handle_read(self):
try:
moredata = self.recv(16384)
except socket.error as e:
if e.errno == errno.EAGAIN:
return
raise
if not moredata:
self.close()
self.schedule_reconnect()
return
self.last_data_received = monotonic_time()
self.readbuf += moredata
global_stats.server_rx_bytes += len(moredata)
self.consume_readbuf()
def send_frame(self, frame):
"""Send a 14-byte message in the Beast binary format, using the magic mlat timestamp"""
# format:
# 1A '3' long frame follows
# FF 00 'MLAT' 6-byte timestamp, this is the magic MLAT timestamp
# 00 signal level
# ... 14 bytes of frame data, with 1A bytes doubled
self.writebuf.extend(b'\x1A3\xFF\x00MLAT\x00')
if b'\x1a' not in frame:
self.writebuf.extend(frame)
else:
for b in frame:
if b == 0x1A:
self.writebuf.append(b)
self.writebuf.append(b)
self.last_write = monotonic_time()
def send_frame(self, frame):
"""Send a 14-byte message in the Beast binary format, using the magic mlat timestamp"""
# format:
# 1A '3' long frame follows
# FF 00 'MLAT' 6-byte timestamp, this is the magic MLAT timestamp
# 00 signal level
# ... 14 bytes of frame data, with 1A bytes doubled
self.writebuf.extend(b'\x1A3\xFF\x00MLAT\x00')
if b'\x1a' not in frame:
self.writebuf.extend(frame)
else:
for b in frame:
if b == 0x1A:
self.writebuf.append(b)
self.writebuf.append(b)
self.last_write = monotonic_time()
def log_and_reset(self):
now = monotonic_time()
elapsed = now - self.start
processed = self.receiver_rx_messages - self.receiver_rx_filtered
log(
'Receiver: {0:6.1f} msg/s received {1:6.1f} msg/s processed ({2:.0f}%)',
self.receiver_rx_messages / elapsed, processed / elapsed,
0 if self.receiver_rx_messages == 0 else 100.0 * processed /
self.receiver_rx_messages)
log(
'Server: {0:6.1f} kB/s from server {1:4.1f}kB/s TCP to server {2:6.1f}kB/s UDP to server',
self.server_rx_bytes / elapsed / 1000.0,
self.server_tx_bytes / elapsed / 1000.0,
self.server_udp_bytes / elapsed / 1000.0)
if self.mlat_positions:
log('Results: {0:3.1f} positions/minute',
self.mlat_positions / elapsed * 60.0)
self.reset(now)
def reconnect(self):
if len(self.addrlist) == 0:
try:
self.addrlist = socket.getaddrinfo(host=self.addr[0],
port=self.addr[1],
family=socket.AF_UNSPEC,
type=socket.SOCK_STREAM,
proto=0,
flags=0)
except socket.error as e:
self.log('{ex!s}', ex=e)
self.next_reconnect = monotonic_time() + self.reconnect_interval
return
# try the next available address
a_family, a_type, a_proto, a_canonname, a_sockaddr = self.addrlist[0]
del self.addrlist[0]
self.output_channel = self.connection_factory(self, None, a_family, a_type, a_sockaddr)
self.output_channel.connect_now()
def reconnect(self):
if len(self.addrlist) == 0:
try:
self.addrlist = socket.getaddrinfo(host=self.addr[0],
port=self.addr[1],
family=socket.AF_UNSPEC,
type=socket.SOCK_STREAM,
proto=0,
flags=0)
except socket.error as e:
self.log('{ex!s}', ex=e)
self.next_reconnect = monotonic_time() + self.reconnect_interval
return
# try the next available address
a_family, a_type, a_proto, a_canonname, a_sockaddr = self.addrlist[0]
del self.addrlist[0]
self.output_channel = self.connection_factory(self, None, a_family, a_type, a_sockaddr)
self.output_channel.connect_now()
def start_connection(self):
log('Connected to multilateration server at {0}:{1}, handshaking',
self.host, self.port)
self.state = 'handshaking'
self.last_data_received = monotonic_time()
compress_methods = ['none']
if self.offer_zlib:
compress_methods.append('zlib')
compress_methods.append('zlib2')
uuid = None
for path in self.uuid_path:
try:
with open(path) as file:
uuid = file.readline().rstrip('\n')
break
except Exception:
pass
handshake_msg = {
'version': 3,
'client_version': mlat.client.version.CLIENT_VERSION,
'compress': compress_methods,
'selective_traffic': True,
'heartbeat': True,
'return_results': self.return_results,
'udp_transport': 2 if self.offer_udp else False,
'return_result_format': 'ecef',
'uuid': uuid
}
handshake_msg.update(self.handshake_data)
if DEBUG:
log("Handshake: {0}", handshake_msg)
self.writebuf += (json.dumps(handshake_msg, sort_keys=True) +
16 * ' ' + '\n').encode(
'ascii') # linebuf not used yet
self.consume_readbuf = self.consume_readbuf_uncompressed
self.handle_server_line = self.handle_handshake_response
def start_connection(self):
log('Connected to multilateration server at {0}:{1}, handshaking', self.host, self.port)
self.state = 'handshaking'
self.last_data_received = monotonic_time()
compress_methods = ['none']
if self.offer_zlib:
compress_methods.append('zlib')
compress_methods.append('zlib2')
handshake_msg = {'version': 3,
'client_version': mlat.client.version.CLIENT_VERSION,
'compress': compress_methods,
'selective_traffic': True,
'heartbeat': True,
'return_results': self.return_results,
'udp_transport': 2 if self.offer_udp else False,
'return_result_format': 'ecef'}
handshake_msg.update(self.handshake_data)
self.writebuf += (json.dumps(handshake_msg) + '\n').encode('ascii') # linebuf not used yet
self.consume_readbuf = self.consume_readbuf_uncompressed
self.handle_server_line = self.handle_handshake_response
def handle_read(self):
try:
moredata = self.recv(16384)
except socket.error as e:
if e.errno == errno.EAGAIN:
return
raise
if not moredata:
self.close()
return
global_stats.receiver_rx_bytes += len(moredata)
if self.residual:
moredata = self.residual + moredata
self.last_data_received = monotonic_time()
try:
consumed, messages = self.packetize(moredata, self.last_timestamp)
except _modes.ClockResetError as e:
log("Problem reading receiver messages: " + str(e))
log("Ensure that only one receiver is feeding data to this client.")
log("A single multilateration client cannot handle data from multiple receivers.")
self.close()
return
if consumed < len(moredata):
self.residual = moredata[consumed:]
if len(self.residual) > 5120:
raise RuntimeError('parser broken - buffer not being consumed')
else:
self.residual = None
if messages:
global_stats.receiver_rx_messages += len(messages)
self.last_timestamp = messages[-1].timestamp
self.coordinator.input_received_messages(messages)
def log_and_reset(self):
now = monotonic_time()
elapsed = now - self.start
processed = self.receiver_rx_messages - self.receiver_rx_filtered
log(
'Receiver: {0:6.1f} msg/s received {1:6.1f} msg/s processed ({2:.0f}%)',
self.receiver_rx_messages / elapsed, processed / elapsed,
0 if self.receiver_rx_messages == 0 else 100.0 * processed /
self.receiver_rx_messages)
if self.receiver_rx_mlat:
log(
'WARNING: Ignored {0:5d} messages with MLAT magic timestamp (do you have --forward-mlat on?)',
self.receiver_rx_mlat)
log(
'Server: {0:6.1f} kB/s from server {1:4.1f}kB/s TCP to server {2:6.1f}kB/s UDP to server',
self.server_rx_bytes / elapsed / 1000.0,
self.server_tx_bytes / elapsed / 1000.0,
self.server_udp_bytes / elapsed / 1000.0)
if self.mlat_positions:
log('Results: {0:3.1f} positions/minute',
self.mlat_positions / elapsed * 60.0)
self.reset(now)
def log_and_reset(self, coordinator):
now = monotonic_time()
elapsed = now - self.start
#log('Receiver status: {0}', coordinator.receiver.state)
#log('Server status: {0}', coordinator.server.state)
processed = self.receiver_rx_messages - self.receiver_rx_filtered
log(
'Receiver: {3:10s} {0:6.1f} msg/s received {1:6.1f} msg/s processed ({2:.0f}%)',
self.receiver_rx_messages / elapsed, processed / elapsed,
0 if self.receiver_rx_messages == 0 else 100.0 * processed /
self.receiver_rx_messages, coordinator.receiver.state)
if self.receiver_rx_mlat:
log(
'WARNING: Ignored {0:5d} messages with MLAT magic timestamp (do you have --forward-mlat on?)',
self.receiver_rx_mlat)
log(
'Server: {0:10s} {1:6.1f} kB/s from server {2:6.1f} kB/s to server',
coordinator.server.state, self.server_rx_bytes / elapsed / 1000.0,
(self.server_tx_bytes + self.server_udp_bytes) / elapsed / 1000.0)
log('Results: {0:3.1f} positions/minute',
self.mlat_positions / elapsed * 60.0)
self.reset(now)
def __init__(self, listener, socket, addr):
asyncore.dispatcher_with_send.__init__(self, sock=socket)
self.listener = listener
self.addr = addr
self.next_heartbeat = monotonic_time() + self.heartbeat_interval
def start_connection(self):
log('Input connected to {0}:{1}', self.host, self.port)
self.last_data_received = monotonic_time()
self.state = 'ready'
self.coordinator.input_connected()
def __init__(self, listener, socket, addr):
super().__init__(listener, socket, addr)
self.next_heartbeat = monotonic_time() + self.heartbeat_interval
def __init__(self, listener, socket, addr):
super().__init__(listener, socket, addr)
self.writebuf = bytearray()
self.last_write = monotonic_time()
def __init__(self, listener, socket, s_family, s_type, addr):
super().__init__(listener, socket, s_family, s_type, addr)
self.writebuf = bytearray()
self.last_write = monotonic_time()
def handle_handshake_response(self, response):
if 'reconnect_in' in response:
self.reconnect_interval = response['reconnect_in']
if 'deny' in response:
log('Server explicitly rejected our connection, saying:')
for reason in response['deny']:
log(' {0}', reason)
raise IOError('Server rejected our connection attempt')
if 'motd' in response:
log('Server says: {0}', response['motd'])
compress = response.get('compress', 'none')
if response['compress'] == 'none':
self.fill_writebuf = self.fill_uncompressed
self.consume_readbuf = self.consume_readbuf_uncompressed
elif response['compress'] == 'zlib' and self.offer_zlib:
self.compressor = zlib.compressobj(1)
self.fill_writebuf = self.fill_zlib
self.consume_readbuf = self.consume_readbuf_uncompressed
elif response['compress'] == 'zlib2' and self.offer_zlib:
self.compressor = zlib.compressobj(1)
self.decompressor = zlib.decompressobj()
self.fill_writebuf = self.fill_zlib
self.consume_readbuf = self.consume_readbuf_zlib
else:
raise IOError(
'Server response asked for a compression method {0}, which we do not support'
.format(response['compress']))
self.server_heartbeat_at = monotonic_time() + self.heartbeat_interval
if 'udp_transport' in response:
host, port, key = response['udp_transport']
if not host:
host = self.host
self.udp_transport = UdpServerConnection(host, port, key)
self.send_mlat = self.udp_transport.send_mlat
self.send_sync = self.udp_transport.send_sync
self.send_split_sync = self.udp_transport.send_split_sync
else:
self.udp_transport = None
self.send_mlat = self.send_tcp_mlat
self.send_sync = self.send_tcp_sync
self.send_split_sync = self.send_tcp_split_sync
# turn off the sync method we don't want
if response.get('split_sync', False):
self.send_sync = None
else:
self.send_split_sync = None
log(
'Handshake complete: Compression {0}, UDP transport {1}, Split sync {2}',
compress, self.udp_transport and str(self.udp_transport)
or 'disabled', self.send_split_sync and 'enabled' or 'disabled')
self.state = 'ready'
self.handle_server_line = self.handle_connected_request
self.coordinator.server_connected()
# dummy rate report to indicate we'll be sending them
self.send_rate_report({})
def handle_handshake_response(self, response):
if 'reconnect_in' in response:
self.reconnect_interval = response['reconnect_in']
if 'deny' in response:
log('Server explicitly rejected our connection, saying:')
for reason in response['deny']:
log(' {0}', reason)
raise IOError('Server rejected our connection attempt')
if 'motd' in response:
log('Server says: {0}', response['motd'])
compress = response.get('compress', 'none')
if response['compress'] == 'none':
self.fill_writebuf = self.fill_uncompressed
self.consume_readbuf = self.consume_readbuf_uncompressed
elif response['compress'] == 'zlib' and self.offer_zlib:
self.compressor = zlib.compressobj(1)
self.fill_writebuf = self.fill_zlib
self.consume_readbuf = self.consume_readbuf_uncompressed
elif response['compress'] == 'zlib2' and self.offer_zlib:
self.compressor = zlib.compressobj(1)
self.decompressor = zlib.decompressobj()
self.fill_writebuf = self.fill_zlib
self.consume_readbuf = self.consume_readbuf_zlib
else:
raise IOError('Server response asked for a compression method {0}, which we do not support'.format(
response['compress']))
self.server_heartbeat_at = monotonic_time() + self.heartbeat_interval
if 'udp_transport' in response:
host, port, key = response['udp_transport']
if not host:
host = self.host
self.udp_transport = UdpServerConnection(host, port, key)
self.send_mlat = self.udp_transport.send_mlat
self.send_sync = self.udp_transport.send_sync
self.send_split_sync = self.udp_transport.send_split_sync
else:
self.udp_transport = None
self.send_mlat = self.send_tcp_mlat
self.send_sync = self.send_tcp_sync
self.send_split_sync = self.send_tcp_split_sync
# turn off the sync method we don't want
if response.get('split_sync', False):
self.send_sync = None
else:
self.send_split_sync = None
log('Handshake complete.')
log(' Compression: {0}', compress)
log(' UDP transport: {0}', self.udp_transport and str(self.udp_transport) or 'disabled')
log(' Split sync: {0}', self.send_split_sync and 'enabled' or 'disabled')
self.state = 'ready'
self.handle_server_line = self.handle_connected_request
self.coordinator.server_connected()
# dummy rate report to indicate we'll be sending them
self.send_rate_report({})
def connection_lost(self, child):
if self.output_channel is child:
self.output_channel = None
self.next_reconnect = monotonic_time() + self.reconnect_interval
def input_received_messages(self, messages):
now = monotonic_time()
for message in messages:
handler = self.df_handlers.get(message.df)
if handler:
handler(message, now)
def schedule_reconnect(self):
if self.reconnect_at is None:
log("Reconnecting in {0} seconds", self.reconnect_interval)
self.reconnect_at = monotonic_time() + self.reconnect_interval
def __init__(self, port, buand, coor):
self.port = serial.Serial(port, baudrate=buand)
self.coordinator = coor
self.next_update_time = monotonic_time() + self.report_interval
if not self.port.isOpen():
self.port.open()
def __init__(self, listener, socket, s_family, s_type, addr):
super().__init__(listener, socket, s_family, s_type, addr)
self.next_heartbeat = monotonic_time() + self.heartbeat_interval
