From 02073745929ba3a62ece36c1502ec160f152b7c7 Mon Sep 17 00:00:00 2001 From: Jakob Ketterl Date: Thu, 15 Aug 2019 15:45:15 +0200 Subject: [PATCH] restructure the code to have the parser sit where all the parsers sit --- csdr.py | 2 +- htdocs/map.js | 2 +- owrx/aprs.py | 172 ++++++++++++++++++++++++++++++++++++++ owrx/connection.py | 4 +- owrx/kiss.py | 201 ++++++--------------------------------------- owrx/service.py | 34 +++++++- owrx/source.py | 8 +- 7 files changed, 238 insertions(+), 185 deletions(-) create mode 100644 owrx/aprs.py diff --git a/csdr.py b/csdr.py index 9211075..f3f42d3 100644 --- a/csdr.py +++ b/csdr.py @@ -235,7 +235,7 @@ class dsp(object): chain = secondary_chain_base + "csdr fmdemod_quadri_cf | " if self.last_decimation != 1.0: chain += "csdr fractional_decimator_ff {last_decimation} | " - chain += "csdr convert_f_s16 | direwolf -r {audio_rate} -t 0 -" + chain += "csdr convert_f_s16 | direwolf -r {audio_rate} -t 0 - 1>&2" return chain def set_secondary_demodulator(self, what): diff --git a/htdocs/map.js b/htdocs/map.js index d235e07..190b0ba 100644 --- a/htdocs/map.js +++ b/htdocs/map.js @@ -290,7 +290,7 @@ } infowindow.setContent( '

' + callsign + '

' + - '
' + timestring + ' using ' + marker.mode + '
' + + '
' + timestring + ' using ' + marker.mode + ( marker.band ? ' on ' + marker.band : '' ) + '
' + commentString ); infowindow.open(map, marker); diff --git a/owrx/aprs.py b/owrx/aprs.py new file mode 100644 index 0000000..e0ead98 --- /dev/null +++ b/owrx/aprs.py @@ -0,0 +1,172 @@ +from owrx.kiss import KissDeframer +from owrx.map import Map, LatLngLocation +from owrx.bands import Bandplan +import logging + +logger = logging.getLogger(__name__) + + +class Ax25Parser(object): + + def parse(self, ax25frame): + control_pid = ax25frame.find(bytes([0x03, 0xf0])) + if control_pid % 7 > 0: + logger.warning("aprs packet framing error: control/pid position not aligned with 7-octet callsign data") + + def chunks(l, n): + """Yield successive n-sized chunks from l.""" + for i in range(0, len(l), n): + yield l[i:i + n] + + return { + "destination": self.extractCallsign(ax25frame[0:7]), + "source": self.extractCallsign(ax25frame[7:14]), + "path": [self.extractCallsign(c) for c in chunks(ax25frame[14:control_pid], 7)], + "data": ax25frame[control_pid+2:] + } + + def extractCallsign(self, input): + cs = bytes([b >> 1 for b in input[0:6]]).decode().strip() + ssid = (input[6] & 0b00011110) >> 1 + if ssid > 0: + return "{callsign}-{ssid}".format(callsign=cs, ssid=ssid) + else: + return cs + + +class AprsParser(object): + + def __init__(self, handler): + self.ax25parser = Ax25Parser() + self.deframer = KissDeframer() + self.dial_freq = None + self.band = None + self.handler = handler + + def setDialFrequency(self, freq): + self.dial_freq = freq + self.band = Bandplan.getSharedInstance().findBand(freq) + + def parse(self, raw): + for frame in self.deframer.parse(raw): + data = self.ax25parser.parse(frame) + + # TODO how can we tell if this is an APRS frame at all? + aprsData = self.parseAprsData(data) + + logger.debug(aprsData) + if "lat" in aprsData and "lon" in aprsData: + loc = LatLngLocation(aprsData["lat"], aprsData["lon"], aprsData["comment"] if "comment" in data else None) + Map.getSharedInstance().updateLocation(data["source"], loc, "APRS", self.band) + + self.handler.write_aprs_data(aprsData) + + def hasCompressedCoordinatesx(self, raw): + return raw[0] == "/" or raw[0] == "\\" + + def parseUncompressedCoordinates(self, raw): + lat = int(raw[0:2]) + float(raw[2:7]) / 60 + if raw[7] == "S": + lat *= -1 + lon = int(raw[9:12]) + float(raw[12:17]) / 60 + if raw[17] == "W": + lon *= -1 + return { + "lat": lat, + "lon": lon, + "symbol": raw[18] + } + + def parseCompressedCoordinates(self, raw): + def decodeBase91(input): + base = decodeBase91(input[:-1]) * 91 if len(input) > 1 else 0 + return base + (ord(input[-1]) - 33) + return { + "lat": 90 - decodeBase91(raw[1:5]) / 380926, + "lon": -180 + decodeBase91(raw[5:9]) / 190463, + "symbol": raw[9] + } + + def parseMicEFrame(self, data): + information = data["data"] + destination = data["destination"] + + def extractNumber(input): + n = ord(input) + if n >= ord("P"): + return n - ord("P") + if n >= ord("A"): + return n - ord("A") + return n - ord("0") + + def listToNumber(input): + base = listToNumber(input[:-1]) * 10 if len(input) > 1 else 0 + return base + input[-1] + + logger.debug(destination) + rawLatitude = [extractNumber(c) for c in destination[0:6]] + logger.debug(rawLatitude) + lat = listToNumber(rawLatitude[0:2]) + listToNumber(rawLatitude[2:6]) / 6000 + if ord(destination[3]) <= ord("9"): + lat *= -1 + + logger.debug(lat) + + logger.debug(information) + lon = information[1] - 28 + if ord(destination[4]) >= ord("P"): + lon += 100 + if 180 <= lon <= 189: + lon -= 80 + if 190 <= lon <= 199: + lon -= 190 + + minutes = information[2] - 28 + if minutes >= 60: + minutes -= 60 + + lon += minutes / 60 + (information[3] - 28) / 6000 + + if ord(destination[5]) >= ord("P"): + lon *= -1 + + return { + "lat": lat, + "lon": lon, + "comment": information[9:].decode() + } + + def parseAprsData(self, data): + information = data["data"] + + # forward some of the ax25 data + aprsData = { + "source": data["source"], + "destination": data["destination"], + "path": data["path"] + } + + if information[0] == 0x1c or information[0] == 0x60: + aprsData.update(self.parseMicEFrame(data)) + return aprsData + + information = information.decode() + logger.debug(information) + + if information[0] == "!" or information[0] == "=": + # position without timestamp + information = information[1:] + elif information[0] == "/" or information[0] == "@": + # position with timestamp + # TODO parse timestamp + information = information[8:] + else: + return {} + + if self.hasCompressedCoordinatesx(information): + aprsData.update(self.parseCompressedCoordinates(information[0:10])) + aprsData["comment"] = information[10:] + else: + aprsData.update(self.parseUncompressedCoordinates(information[0:19])) + aprsData["comment"] = information[19:] + return aprsData diff --git a/owrx/connection.py b/owrx/connection.py index 7460afa..f873dc0 100644 --- a/owrx/connection.py +++ b/owrx/connection.py @@ -205,8 +205,8 @@ class OpenWebRxReceiverClient(Client): def write_dial_frequendies(self, frequencies): self.protected_send({"type": "dial_frequencies", "value": frequencies}) - def write_packet_data(self, data): - self.protected_send({"type": "packet_data", "value": data}) + def write_aprs_data(self, data): + self.protected_send({"type": "aprs_data", "value": data}) class MapConnection(Client): diff --git a/owrx/kiss.py b/owrx/kiss.py index 43f8e64..8338d91 100644 --- a/owrx/kiss.py +++ b/owrx/kiss.py @@ -1,6 +1,5 @@ import socket import time -from owrx.map import Map, LatLngLocation import logging logger = logging.getLogger(__name__) @@ -10,23 +9,6 @@ FESC = 0xDB TFEND = 0xDC TFESC = 0XDD -def group(a, *ns): - for n in ns: - a = [a[i:i+n] for i in range(0, len(a), n)] - return a - -def join(a, *cs): - return [cs[0].join(join(t, *cs[1:])) for t in a] if cs else a - -def hexdump(data): - toHex = lambda c: '{:02X}'.format(c) - toChr = lambda c: chr(c) if 32 <= c < 127 else '.' - make = lambda f, *cs: join(group(list(map(f, data)), 8, 2), *cs) - hs = make(toHex, ' ', ' ') - cs = make(toChr, ' ', '') - for i, (h, c) in enumerate(zip(hs, cs)): - print ('{:010X}: {:48} {:16}'.format(i * 16, h, c)) - class KissClient(object): def __init__(self, port): @@ -35,167 +17,32 @@ class KissClient(object): self.socket.connect(("localhost", port)) def read(self): - buf = bytes() - escaped = False - while True: - input = self.socket.recv(1) - # EOF - if len(input) == 0: - return bytes() + return self.socket.recv(1) - if input[0] == FESC: - escaped = True - elif escaped: - if input[0] == TFEND: - buf += [FEND] - elif input[0] == TFESC: - buf += [FESC] + +class KissDeframer(object): + def __init__(self): + self.escaped = False + self.buf = bytearray() + + def parse(self, input): + frames = [] + for b in input: + if b == FESC: + self.escaped = True + elif self.escaped: + if b == TFEND: + self.buf.append(FEND) + elif b == TFESC: + self.buf.append(FESC) else: logger.warning("invalid escape char: %s", str(input[0])) - escaped = False + self.escaped = False elif input[0] == FEND: - logger.debug("decoded frame: " + str(buf)) - if len(buf) > 0: - try: - return self.parseFrame(buf) - except Exception: - logger.exception("failed to decode packet data") - return {} + # data frames start with 0x00 + if len(self.buf) > 1 and self.buf[0] == 0x00: + frames += [self.buf[1:]] + self.buf = bytearray() else: - buf += input - - def parseFrame(self, frame): - # data frames start with 0x00 - if frame[0] != 0x00: - return {} - ax25frame = frame[1:] - control_pid = ax25frame.find(bytes([0x03, 0xf0])) - if control_pid % 7 > 0: - logger.warning("aprs packet framing error: control/pid position not aligned with 7-octet callsign data") - - def chunks(l, n): - """Yield successive n-sized chunks from l.""" - for i in range(0, len(l), n): - yield l[i:i + n] - - information = ax25frame[control_pid+2:] - - data = { - "destination": self.extractCallsign(ax25frame[0:7]), - "source": self.extractCallsign(ax25frame[7:14]), - "path": [self.extractCallsign(c) for c in chunks(ax25frame[14:control_pid], 7)] - } - # TODO how can we tell if this is an APRS frame at all? - aprsData = self.parseAprsData(data["destination"], information) - data.update(aprsData) - - logger.debug(data) - if "lat" in data and "lon" in data: - loc = LatLngLocation(data["lat"], data["lon"], data["comment"] if "comment" in data else None) - Map.getSharedInstance().updateLocation(data["source"], loc, "APRS") - return data - - def hasCompressedCoordinatesx(self, raw): - return raw[0] == "/" or raw[0] == "\\" - - def parseUncompressedCoordinates(self, raw): - lat = int(raw[0:2]) + float(raw[2:7]) / 60 - if raw[7] == "S": - lat *= -1 - lon = int(raw[9:12]) + float(raw[12:17]) / 60 - if raw[17] == "W": - lon *= -1 - return { - "lat": lat, - "lon": lon, - "symbol": raw[18] - } - - def parseCompressedCoordinates(self, raw): - def decodeBase91(input): - base = decodeBase91(input[:-1]) * 91 if len(input) > 1 else 0 - return base + (ord(input[-1]) - 33) - return { - "lat": 90 - decodeBase91(raw[1:5]) / 380926, - "lon": -180 + decodeBase91(raw[5:9]) / 190463, - "symbol": raw[9] - } - - def parseMicEFrame(self, destination, information): - def extractNumber(input): - n = ord(input) - if n >= ord("P"): - return n - ord("P") - if n >= ord("A"): - return n - ord("A") - return n - ord("0") - - def listToNumber(input): - base = listToNumber(input[:-1]) * 10 if len(input) > 1 else 0 - return base + input[-1] - - logger.debug(destination) - rawLatitude = [extractNumber(c) for c in destination[0:6]] - logger.debug(rawLatitude) - lat = listToNumber(rawLatitude[0:2]) + listToNumber(rawLatitude[2:6]) / 6000 - if ord(destination[3]) <= ord("9"): - lat *= -1 - - logger.debug(lat) - - logger.debug(information) - lon = information[1] - 28 - if ord(destination[4]) >= ord("P"): - lon += 100 - if 180 <= lon <= 189: - lon -= 80 - if 190 <= lon <= 199: - lon -= 190 - - minutes = information[2] - 28 - if minutes >= 60: - minutes -= 60 - - lon += minutes / 60 + (information[3] - 28) / 6000 - - if ord(destination[5]) >= ord("P"): - lon *= -1 - - return { - "lat": lat, - "lon": lon, - "comment": information[9:].decode() - } - - def parseAprsData(self, destination, information): - if information[0] == 0x1c or information[0] == 0x60: - return self.parseMicEFrame(destination, information) - - information = information.decode() - logger.debug(information) - - if information[0] == "!" or information[0] == "=": - # position without timestamp - information = information[1:] - elif information[0] == "/" or information[0] == "@": - # position with timestamp - # TODO parse timestamp - information = information[8:] - else: - return {} - - if self.hasCompressedCoordinatesx(information): - coords = self.parseCompressedCoordinates(information[0:10]) - coords["comment"] = information[10:] - else: - coords = self.parseUncompressedCoordinates(information[0:19]) - coords["comment"] = information[19:] - return coords - - def extractCallsign(self, input): - cs = bytes([b >> 1 for b in input[0:6]]).decode().strip() - ssid = (input[6] & 0b00011110) >> 1 - if ssid > 0: - return "{callsign}-{ssid}".format(callsign=cs, ssid=ssid) - else: - return cs + self.buf.append(b) + return frames diff --git a/owrx/service.py b/owrx/service.py index 0ae7390..c3d598e 100644 --- a/owrx/service.py +++ b/owrx/service.py @@ -3,6 +3,7 @@ from owrx.source import SdrService from owrx.bands import Bandplan from csdr import dsp, output from owrx.wsjt import WsjtParser +from owrx.aprs import AprsParser from owrx.config import PropertyManager import logging @@ -14,16 +15,35 @@ class ServiceOutput(output): def __init__(self, frequency): self.frequency = frequency + def getParser(self): + # abstract method; implement in subclasses + pass + def receive_output(self, t, read_fn): - parser = WsjtParser(WsjtHandler()) + parser = self.getParser() parser.setDialFrequency(self.frequency) target = self.pump(read_fn, parser.parse) threading.Thread(target=target).start() + +class WsjtServiceOutput(ServiceOutput): + + def getParser(self): + return WsjtParser(WsjtHandler()) + def supports_type(self, t): return t == "wsjt_demod" +class AprsServiceOutput(ServiceOutput): + + def getParser(self): + return AprsParser(AprsHandler()) + + def supports_type(self, t): + return t == "packet_demod" + + class ServiceHandler(object): def __init__(self, source): self.services = [] @@ -77,7 +97,12 @@ class ServiceHandler(object): def setupService(self, mode, frequency): logger.debug("setting up service {0} on frequency {1}".format(mode, frequency)) - d = dsp(ServiceOutput(frequency)) + # TODO selecting outputs will need some more intelligence here + if mode == "packet": + output = AprsServiceOutput(frequency) + else: + output = WsjtServiceOutput(frequency) + d = dsp(output) d.nc_port = self.source.getPort() d.set_offset_freq(frequency - self.source.getProps()["center_freq"]) if mode == "packet": @@ -98,6 +123,11 @@ class WsjtHandler(object): pass +class AprsHandler(object): + def write_aprs_data(self, data): + pass + + class ServiceManager(object): sharedInstance = None diff --git a/owrx/source.py b/owrx/source.py index fe45ccc..e867af6 100644 --- a/owrx/source.py +++ b/owrx/source.py @@ -3,6 +3,7 @@ from owrx.config import PropertyManager from owrx.feature import FeatureDetector, UnknownFeatureException from owrx.meta import MetaParser from owrx.wsjt import WsjtParser +from owrx.aprs import AprsParser import threading import csdr import time @@ -406,6 +407,7 @@ class DspManager(csdr.output): self.sdrSource = sdrSource self.metaParser = MetaParser(self.handler) self.wsjtParser = WsjtParser(self.handler) + self.aprsParser = AprsParser(self.handler) self.localProps = ( self.sdrSource.getProps() @@ -440,7 +442,9 @@ class DspManager(csdr.output): self.dsp.set_bpf(*bpf) def set_dial_freq(key, value): - self.wsjtParser.setDialFrequency(self.localProps["center_freq"] + self.localProps["offset_freq"]) + freq = self.localProps["center_freq"] + self.localProps["offset_freq"] + self.wsjtParser.setDialFrequency(freq) + self.aprsParser.setDialFrequency(freq) self.subscriptions = [ self.localProps.getProperty("audio_compression").wire(self.dsp.set_audio_compression), @@ -502,7 +506,7 @@ class DspManager(csdr.output): "secondary_demod": self.handler.write_secondary_demod, "meta": self.metaParser.parse, "wsjt_demod": self.wsjtParser.parse, - "packet_demod": self.handler.write_packet_data, + "packet_demod": self.aprsParser.parse, } write = writers[t]