Added raw gps, item report and station

This patch adds raw gps parsing, item report parsing
and station capabilities parsing.

Author: hemna

aprslib/parsing/__init__.py

@@ -46,16 +46,13 @@ def detect(x):
 
 unsupported_formats = {
         '#':'raw weather report',
-        '$':'raw gps',
         '%':'agrelo',
         '&':'reserved',
         '(':'unused',
-        ')':'item report',
         '*':'complete weather report',
         '+':'reserved',
         '-':'unused',
         '.':'reserved',
-        '<':'station capabilities',
         '?':'general query format',
         '[':'maidenhead locator beacon',
         '\\':'unused',
@@ -125,7 +122,7 @@ def parse(packet):
     packet_type = body[0]
     body = body[1:]
 
-    if len(body) == 0 and packet_type != '>':
+    if len(body) == 0 and packet_type not in '><$':
         raise ParseError("packet body is empty after packet type character", packet)
 
     # attempt to parse the body
@@ -207,6 +204,24 @@ def _try_toparse_body(packet_type, body, parsed):
 
         body, result = parse_telemetry_report(body)
 
+    # Station capabilities
+    elif packet_type == '<':
+        logger.debug("Attempting to parse as station capabilities")
+
+        body, result = parse_station_capabilities(body)
+
+    # Raw GPS
+    elif packet_type == '$':
+        logger.debug("Attempting to parse as raw GPS")
+
+        body, result = parse_raw_gps(body)
+
+    # Item report
+    elif packet_type == ')':
+        logger.debug("Attempting to parse as item report")
+
+        body, result = parse_position(packet_type, body)
+
     # postion report (regular or compressed)
     elif (packet_type in '!=/@;' or
           0 <= body.find('!') < 40):  # page 28 of spec (PDF)

aprslib/parsing/misc.py

@@ -6,6 +6,8 @@
         'parse_status',
         'parse_invalid',
         'parse_user_defined',
+        'parse_station_capabilities',
+        'parse_raw_gps',
         ]
 
 
@@ -45,3 +47,255 @@ def parse_user_defined(body):
         'type': body[1],
         'body': body[2:],
         })
+
+
+# STATION CAPABILITIES
+#
+# <IGATE,MSG_CNT=n,LOC_CNT=n
+# Format: <TOKEN,TOKEN=VALUE,TOKEN=VALUE,...
+def parse_station_capabilities(body):
+    """
+    Parses APRS station capabilities format: <TOKEN,TOKEN=VALUE,TOKEN=VALUE,...
+
+    Format:
+    - < indicates station capabilities packet
+    - Comma-separated list of capabilities
+    - Each capability can be:
+      - TOKEN (e.g., "IGATE")
+      - TOKEN=VALUE (e.g., "MSG_CNT=123", "LOC_CNT=5")
+
+    Returns (remaining_body, parsed_dict)
+    """
+    parsed = {
+        'format': 'station-capabilities',
+        'capabilities': {}
+    }
+
+    if not body:
+        return ('', parsed)
+
+    # Split by comma to get individual capabilities
+    capabilities = body.split(',')
+
+    for cap in capabilities:
+        cap = cap.strip()
+        if not cap:
+            continue
+
+        # Check if it's TOKEN=VALUE format
+        if '=' in cap:
+            parts = cap.split('=', 1)
+            if len(parts) != 2:
+                continue
+
+            token = parts[0].strip()
+            value = parts[1].strip()
+
+            # Try to convert value to number if possible
+            try:
+                # Try integer first
+                if value.isdigit() or (value.startswith('-') and value[1:].isdigit()):
+                    value = int(value)
+                else:
+                    # Try float
+                    try:
+                        value = float(value)
+                    except ValueError:
+                        pass  # Keep as string
+            except (ValueError, AttributeError):
+                pass  # Keep as string
+
+            parsed['capabilities'][token] = value
+        else:
+            # It's just a TOKEN (boolean capability)
+            parsed['capabilities'][cap] = True
+
+    return ('', parsed)
+
+
+# RAW GPS
+#
+# $GPRMC,...
+# $GPGGA,...
+# $ULTW...
+# Format: $<FORMAT><DATA>
+def parse_raw_gps(body):
+    """
+    Parses APRS raw GPS format: $<FORMAT><DATA>
+
+    Format:
+    - $ indicates raw GPS/data packet
+    - Can be NMEA sentences (e.g., $GPRMC, $GPGGA, $GPGLL)
+    - Can be proprietary formats (e.g., $ULTW for weather)
+    - Data can be comma-separated (NMEA) or hex-encoded
+
+    Returns (remaining_body, parsed_dict)
+    """
+    parsed = {
+        'format': 'raw-gps',
+        'raw_data': body
+    }
+
+    if not body:
+        return ('', parsed)
+
+    # Try to identify the format
+    # NMEA sentences start with GP, GL, GN, etc. followed by sentence type (note: $ is already stripped)
+    nmea_match = re.match(r'^([A-Z]{2})([A-Z]{3,5})(,.*)?$', body)
+    if nmea_match:
+        talker_id = nmea_match.group(1)  # GP, GL, GN, etc.
+        sentence_type = nmea_match.group(2)  # RMC, GGA, GLL, etc.
+        data = nmea_match.group(3) if nmea_match.group(3) else ''
+
+        # Clean the data (remove leading comma, strip checksum if present)
+        clean_data = data.lstrip(',') if data else ''
+        # Remove checksum if present (format: *HH)
+        if '*' in clean_data:
+            clean_data = clean_data[:clean_data.rfind('*')]
+
+        parsed.update({
+            'nmea_talker': talker_id,
+            'nmea_sentence': sentence_type,
+            'nmea_data': clean_data
+        })
+
+        # Try to parse common NMEA sentences
+        if sentence_type == 'RMC' and clean_data:
+            # Recommended Minimum Course
+            # Format: $GPRMC,hhmmss.ss,A,llll.ll,a,yyyyy.yy,a,x.x,x.x,ddmmyy,x.x,a*hh
+            parts = clean_data.split(',')
+            if len(parts) >= 10:
+                try:
+                    time_str = parts[0] if parts[0] else None
+                    status = parts[1] if len(parts) > 1 else None
+                    lat_str = parts[2] if len(parts) > 2 else None
+                    lat_dir = parts[3] if len(parts) > 3 else None
+                    lon_str = parts[4] if len(parts) > 4 else None
+                    lon_dir = parts[5] if len(parts) > 5 else None
+                    speed = parts[6] if len(parts) > 6 else None
+                    course = parts[7] if len(parts) > 7 else None
+                    date_str = parts[8] if len(parts) > 8 else None
+
+                    if lat_str and lat_dir and lon_str and lon_dir:
+                        # Parse latitude (DDMM.MMMM format)
+                        lat_deg = float(lat_str[:2])
+                        lat_min = float(lat_str[2:])
+                        latitude = lat_deg + lat_min / 60.0
+                        if lat_dir == 'S':
+                            latitude = -latitude
+
+                        # Parse longitude (DDDMM.MMMM format)
+                        lon_deg = float(lon_str[:3])
+                        lon_min = float(lon_str[3:])
+                        longitude = lon_deg + lon_min / 60.0
+                        if lon_dir == 'W':
+                            longitude = -longitude
+
+                        parsed.update({
+                            'latitude': latitude,
+                            'longitude': longitude,
+                        })
+
+                        if speed:
+                            try:
+                                parsed['speed'] = float(speed) * 1.852  # knots to km/h
+                            except (ValueError, TypeError):
+                                pass
+
+                        if course:
+                            try:
+                                parsed['course'] = float(course)
+                            except (ValueError, TypeError):
+                                pass
+
+                        if time_str and date_str:
+                            try:
+                                # Combine date and time for timestamp
+                                # Format: hhmmss.ss and ddmmyy
+                                parsed['nmea_time'] = time_str
+                                parsed['nmea_date'] = date_str
+                            except (ValueError, TypeError):
+                                pass
+
+                        if status:
+                            parsed['gps_status'] = status  # A = valid, V = invalid
+                except (ValueError, IndexError, AttributeError):
+                    pass  # If parsing fails, just store raw data
+
+        elif sentence_type == 'GGA' and clean_data:
+            # Global Positioning System Fix Data
+            # Format: $GPGGA,hhmmss.ss,llll.ll,a,yyyyy.yy,a,x,xx,x.x,x.x,M,x.x,M,x.x,xxxx*hh
+            parts = clean_data.split(',')
+            if len(parts) >= 10:
+                try:
+                    time_str = parts[0] if parts[0] else None
+                    lat_str = parts[1] if len(parts) > 1 else None
+                    lat_dir = parts[2] if len(parts) > 2 else None
+                    lon_str = parts[3] if len(parts) > 3 else None
+                    lon_dir = parts[4] if len(parts) > 4 else None
+                    fix_quality = parts[5] if len(parts) > 5 else None
+                    num_satellites = parts[6] if len(parts) > 6 else None
+                    hdop = parts[7] if len(parts) > 7 else None
+                    altitude = parts[8] if len(parts) > 8 else None
+                    altitude_units = parts[9] if len(parts) > 9 else None
+
+                    if lat_str and lat_dir and lon_str and lon_dir:
+                        # Parse latitude
+                        lat_deg = float(lat_str[:2])
+                        lat_min = float(lat_str[2:])
+                        latitude = lat_deg + lat_min / 60.0
+                        if lat_dir == 'S':
+                            latitude = -latitude
+
+                        # Parse longitude
+                        lon_deg = float(lon_str[:3])
+                        lon_min = float(lon_str[3:])
+                        longitude = lon_deg + lon_min / 60.0
+                        if lon_dir == 'W':
+                            longitude = -longitude
+
+                        parsed.update({
+                            'latitude': latitude,
+                            'longitude': longitude,
+                        })
+
+                        if altitude and altitude_units == 'M':
+                            try:
+                                parsed['altitude'] = float(altitude)
+                            except (ValueError, TypeError):
+                                pass
+
+                        if fix_quality:
+                            try:
+                                parsed['gps_fix_quality'] = int(fix_quality)
+                            except (ValueError, TypeError):
+                                pass
+
+                        if num_satellites:
+                            try:
+                                parsed['gps_satellites'] = int(num_satellites)
+                            except (ValueError, TypeError):
+                                pass
+                except (ValueError, IndexError, AttributeError):
+                    pass
+
+    # Check for proprietary formats like ULTW (4-letter format ID)
+    elif re.match(r'^[A-Z]{4}', body) and len(body) >= 4:
+        format_id = body[0:4]
+        hex_data = body[4:] if len(body) > 4 else ''
+
+        parsed.update({
+            'format_id': format_id,
+            'hex_data': hex_data
+        })
+
+        # ULTW is Ultimeter weather format
+        if format_id == 'ULTW' and hex_data:
+            parsed['ultimeter_format'] = True
+            # ULTW data is 52 hex characters (13 fields of 4 hex chars each)
+            if len(hex_data) >= 52:
+                parsed['ultimeter_data'] = hex_data[:52]
+                if len(hex_data) > 52:
+                    parsed['ultimeter_extra'] = hex_data[52:]
+
+    return ('', parsed)

aprslib/parsing/position.py

@@ -15,11 +15,22 @@
 def parse_position(packet_type, body):
     parsed = {}
 
-    if packet_type not in '!=/@;':
-        _, body = body.split('!', 1)
-        packet_type = '!'
+    # Handle item reports first (before the ! split logic)
+    if packet_type == ')':
+        logger.debug("Attempting to parse item report format")
+        # Item name is 3-9 characters, followed by ! (live) or _ (kill)
+        match = re.findall(r"^([!-~]{3,9})([!_])", body)
+        if match:
+            name, flag = match[0]
+            parsed.update({
+                'item_name': name,
+                'alive': flag == '!',
+                })
 
-    if packet_type == ';':
+            body = body[len(name) + 1:]
+        else:
+            raise ParseError("invalid item report format")
+    elif packet_type == ';':
         logger.debug("Attempting to parse object report format")
         match = re.findall(r"^([ -~]{9})(\*|_)", body)
         if match:
@@ -32,11 +43,14 @@ def parse_position(packet_type, body):
             body = body[10:]
         else:
             raise ParseError("invalid format")
+    elif packet_type not in '!=/@':
+        _, body = body.split('!', 1)
+        packet_type = '!'
     else:
         parsed.update({"messagecapable": packet_type in '@='})
 
     # decode timestamp
-    if packet_type in "/@;":
+    if packet_type in "/@;)":
         body, result = parse_timestamp(body, packet_type)
         parsed.update(result)
 
@@ -80,6 +94,11 @@ def parse_position(packet_type, body):
             'object_format': parsed['format'],
             'format': 'object',
             })
+    elif packet_type == ')':
+        parsed.update({
+            'item_format': parsed['format'],
+            'format': 'item',
+            })
 
     return ('', parsed)